|
|
|
|
|
|
|
|
|
|
|
|
# 🔋 Sponsorship
================================================
FILE: README_ZH.md
================================================
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
# 🔋 赞助商
================================================
FILE: acceptor_unix.go
================================================
// Copyright (c) 2021 The Gnet Authors. All rights reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//go:build darwin || dragonfly || freebsd || linux || netbsd || openbsd
package gnet
import (
"runtime"
"golang.org/x/sys/unix"
"github.com/panjf2000/gnet/v2/pkg/errors"
"github.com/panjf2000/gnet/v2/pkg/netpoll"
"github.com/panjf2000/gnet/v2/pkg/queue"
"github.com/panjf2000/gnet/v2/pkg/socket"
)
func (el *eventloop) accept0(fd int, _ netpoll.IOEvent, _ netpoll.IOFlags) error {
for {
nfd, sa, err := socket.Accept(fd)
switch err {
case nil:
case unix.EAGAIN: // the Accept queue has been drained out, we can return now
return nil
case unix.EINTR, unix.ECONNRESET, unix.ECONNABORTED:
// ECONNRESET or ECONNABORTED could indicate that a socket
// in the Accept queue was closed before we Accept()ed it.
// It's a silly error, let's retry it.
continue
default:
el.getLogger().Errorf("Accept() failed due to error: %v", err)
return errors.ErrAcceptSocket
}
remoteAddr := socket.SockaddrToTCPOrUnixAddr(sa)
network := el.listeners[fd].network
if opts := el.engine.opts; opts.TCPKeepAlive > 0 && network == "tcp" &&
(runtime.GOOS != "linux" && runtime.GOOS != "freebsd" && runtime.GOOS != "dragonfly") {
// TCP keepalive options are not inherited from the listening socket
// on platforms other than Linux, FreeBSD, or DragonFlyBSD.
// We therefore need to set them on the accepted socket explicitly.
//
// Check out https://github.com/nginx/nginx/pull/337 for details.
if err = setKeepAlive(
nfd,
true,
opts.TCPKeepAlive,
opts.TCPKeepInterval,
opts.TCPKeepCount); err != nil {
el.getLogger().Errorf("failed to set TCP keepalive on fd=%d: %v", fd, err)
}
}
el := el.engine.eventLoops.next(remoteAddr)
c := newStreamConn(network, nfd, el, sa, el.listeners[fd].addr, remoteAddr)
err = el.poller.Trigger(queue.HighPriority, el.register, c)
if err != nil {
el.getLogger().Errorf("failed to enqueue the accepted socket fd=%d to poller: %v", c.fd, err)
_ = unix.Close(nfd)
c.release()
}
}
}
func (el *eventloop) accept(fd int, ev netpoll.IOEvent, flags netpoll.IOFlags) error {
network := el.listeners[fd].network
if network == "udp" {
return el.readUDP(fd, ev, flags)
}
nfd, sa, err := socket.Accept(fd)
switch err {
case nil:
case unix.EINTR, unix.EAGAIN, unix.ECONNRESET, unix.ECONNABORTED:
// ECONNRESET or ECONNABORTED could indicate that a socket
// in the Accept queue was closed before we Accept()ed it.
// It's a silly error, let's retry it.
return nil
default:
el.getLogger().Errorf("Accept() failed due to error: %v", err)
return errors.ErrAcceptSocket
}
remoteAddr := socket.SockaddrToTCPOrUnixAddr(sa)
if opts := el.engine.opts; opts.TCPKeepAlive > 0 && el.listeners[fd].network == "tcp" &&
(runtime.GOOS != "linux" && runtime.GOOS != "freebsd" && runtime.GOOS != "dragonfly") {
// TCP keepalive options are not inherited from the listening socket
// on platforms other than Linux, FreeBSD, or DragonFlyBSD.
// We therefore need to set them on the accepted socket explicitly.
//
// Check out https://github.com/nginx/nginx/pull/337 for details.
if err = setKeepAlive(
nfd,
true,
opts.TCPKeepAlive,
opts.TCPKeepInterval,
opts.TCPKeepCount); err != nil {
el.getLogger().Errorf("failed to set TCP keepalive on fd=%d: %v", fd, err)
}
}
c := newStreamConn(network, nfd, el, sa, el.listeners[fd].addr, remoteAddr)
return el.register0(c)
}
================================================
FILE: acceptor_windows.go
================================================
// Copyright (c) 2023 The Gnet Authors. All rights reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
package gnet
import (
"errors"
"net"
"runtime"
errorx "github.com/panjf2000/gnet/v2/pkg/errors"
"github.com/panjf2000/gnet/v2/pkg/pool/goroutine"
)
func (eng *engine) listenStream(ln net.Listener) (err error) {
if eng.opts.LockOSThread {
runtime.LockOSThread()
defer runtime.UnlockOSThread()
}
defer func() { eng.shutdown(err) }()
for {
// Accept TCP socket.
tc, e := ln.Accept()
if e != nil {
err = e
if !eng.beingShutdown.Load() {
eng.opts.Logger.Errorf("Accept() fails due to error: %v", err)
} else if errors.Is(err, net.ErrClosed) {
err = errors.Join(err, errorx.ErrEngineShutdown)
}
return
}
el := eng.eventLoops.next(tc.RemoteAddr())
c := newStreamConn(el, tc, nil)
el.ch <- &openConn{c: c}
goroutine.DefaultWorkerPool.Submit(func() {
var buffer [0x10000]byte
for {
n, err := tc.Read(buffer[:])
if err != nil {
el.ch <- &netErr{c, err}
return
}
el.ch <- packTCPConn(c, buffer[:n])
}
})
}
}
func (eng *engine) ListenUDP(pc net.PacketConn) (err error) {
if eng.opts.LockOSThread {
runtime.LockOSThread()
defer runtime.UnlockOSThread()
}
defer func() { eng.shutdown(err) }()
var buffer [0x10000]byte
for {
// Read data from UDP socket.
n, addr, e := pc.ReadFrom(buffer[:])
if e != nil {
err = e
if !eng.beingShutdown.Load() {
eng.opts.Logger.Errorf("failed to receive data from UDP fd due to error:%v", err)
} else if errors.Is(err, net.ErrClosed) {
err = errors.Join(err, errorx.ErrEngineShutdown)
}
return
}
el := eng.eventLoops.next(addr)
c := newUDPConn(el, pc, nil, pc.LocalAddr(), addr, nil)
el.ch <- packUDPConn(c, buffer[:n])
}
}
================================================
FILE: client_test.go
================================================
//go:build darwin || dragonfly || freebsd || linux || netbsd || openbsd || windows
package gnet
import (
"bytes"
crand "crypto/rand"
"io"
"math/rand"
"net"
"path/filepath"
"sync"
"sync/atomic"
"testing"
"time"
"github.com/stretchr/testify/assert"
"go.uber.org/zap"
errorx "github.com/panjf2000/gnet/v2/pkg/errors"
"github.com/panjf2000/gnet/v2/pkg/logging"
bbPool "github.com/panjf2000/gnet/v2/pkg/pool/bytebuffer"
goPool "github.com/panjf2000/gnet/v2/pkg/pool/goroutine"
)
type connHandler struct {
network string
rspCh chan []byte
data []byte
}
type clientEvents struct {
*BuiltinEventEngine
tester *testing.T
svr *testClient
}
func (ev *clientEvents) OnBoot(e Engine) Action {
fd, err := e.Dup()
assert.ErrorIsf(ev.tester, err, errorx.ErrEmptyEngine, "expected error: %v, but got: %v",
errorx.ErrUnsupportedOp, err)
assert.EqualValuesf(ev.tester, fd, -1, "expected -1, but got: %d", fd)
fd, err = e.DupListener("tcp", "abc")
assert.ErrorIsf(ev.tester, err, errorx.ErrEmptyEngine, "expected error: %v, but got: %v",
errorx.ErrUnsupportedOp, err)
assert.EqualValuesf(ev.tester, fd, -1, "expected -1, but got: %d", fd)
return None
}
var pingMsg = []byte("PING\r\n")
func (ev *clientEvents) OnOpen(Conn) (out []byte, action Action) {
out = pingMsg
return
}
func (ev *clientEvents) OnClose(Conn, error) Action {
if ev.svr != nil {
if atomic.AddInt32(&ev.svr.clientActive, -1) == 0 {
return Shutdown
}
}
return None
}
func (ev *clientEvents) OnTraffic(c Conn) (action Action) {
handler := c.Context().(*connHandler)
packetLen := streamLen
if handler.network == "udp" {
packetLen = datagramLen
}
buf, err := c.Next(-1)
assert.NoError(ev.tester, err)
handler.data = append(handler.data, buf...)
if len(handler.data) < packetLen {
return
}
handler.rspCh <- handler.data
handler.data = nil
return
}
func (ev *clientEvents) OnTick() (delay time.Duration, action Action) {
delay = 200 * time.Millisecond
return
}
func (ev *clientEvents) OnShutdown(e Engine) {
fd, err := e.Dup()
assert.ErrorIsf(ev.tester, err, errorx.ErrEmptyEngine, "expected error: %v, but got: %v",
errorx.ErrUnsupportedOp, err)
assert.EqualValuesf(ev.tester, fd, -1, "expected -1, but got: %d", fd)
fd, err = e.DupListener("tcp", "abc")
assert.ErrorIsf(ev.tester, err, errorx.ErrEmptyEngine, "expected error: %v, but got: %v",
errorx.ErrUnsupportedOp, err)
assert.EqualValuesf(ev.tester, fd, -1, "expected -1, but got: %d", fd)
}
func TestClient(t *testing.T) {
// start an engine
// connect 10 clients
// each client will pipe random data for 1-3 seconds.
// the writes to the engine will be random sizes. 0KB - 1MB.
// the engine will echo back the data.
// waits for graceful connection closing.
t.Run("poll-LT", func(t *testing.T) {
t.Run("tcp", func(t *testing.T) {
t.Run("1-loop", func(t *testing.T) {
runClient(t, "tcp", ":9991", &testConf{false, 0, false, false, false, false, 10, RoundRobin})
})
t.Run("N-loop", func(t *testing.T) {
runClient(t, "tcp", ":9992", &testConf{false, 0, false, true, false, false, 10, LeastConnections})
})
})
t.Run("tcp-async", func(t *testing.T) {
t.Run("1-loop", func(t *testing.T) {
runClient(t, "tcp", ":9991", &testConf{false, 0, false, false, true, false, 10, RoundRobin})
})
t.Run("N-loop", func(t *testing.T) {
runClient(t, "tcp", ":9992", &testConf{false, 0, false, true, true, false, 10, LeastConnections})
})
})
t.Run("udp", func(t *testing.T) {
t.Run("1-loop", func(t *testing.T) {
runClient(t, "udp", ":9991", &testConf{false, 0, false, false, false, false, 10, RoundRobin})
})
t.Run("N-loop", func(t *testing.T) {
runClient(t, "udp", ":9992", &testConf{false, 0, false, true, false, false, 10, LeastConnections})
})
})
t.Run("udp-async", func(t *testing.T) {
t.Run("1-loop", func(t *testing.T) {
runClient(t, "udp", ":9991", &testConf{false, 0, false, false, true, false, 10, RoundRobin})
})
t.Run("N-loop", func(t *testing.T) {
runClient(t, "udp", ":9992", &testConf{false, 0, false, true, true, false, 10, LeastConnections})
})
})
t.Run("unix", func(t *testing.T) {
t.Run("1-loop", func(t *testing.T) {
runClient(t, "unix", testUnixAddr(t), &testConf{false, 0, false, false, false, false, 10, RoundRobin})
})
t.Run("N-loop", func(t *testing.T) {
runClient(t, "unix", testUnixAddr(t), &testConf{false, 0, false, true, false, false, 10, SourceAddrHash})
})
})
t.Run("unix-async", func(t *testing.T) {
t.Run("1-loop", func(t *testing.T) {
runClient(t, "unix", testUnixAddr(t), &testConf{false, 0, false, false, true, false, 10, RoundRobin})
})
t.Run("N-loop", func(t *testing.T) {
runClient(t, "unix", testUnixAddr(t), &testConf{false, 0, false, true, true, false, 10, SourceAddrHash})
})
})
})
t.Run("poll-ET", func(t *testing.T) {
t.Run("tcp", func(t *testing.T) {
t.Run("1-loop", func(t *testing.T) {
runClient(t, "tcp", ":9991", &testConf{true, 0, false, false, false, false, 10, RoundRobin})
})
t.Run("N-loop", func(t *testing.T) {
runClient(t, "tcp", ":9992", &testConf{true, 0, false, true, false, false, 10, LeastConnections})
})
})
t.Run("tcp-async", func(t *testing.T) {
t.Run("1-loop", func(t *testing.T) {
runClient(t, "tcp", ":9991", &testConf{true, 0, false, false, true, false, 10, RoundRobin})
})
t.Run("N-loop", func(t *testing.T) {
runClient(t, "tcp", ":9992", &testConf{true, 0, false, true, true, false, 10, LeastConnections})
})
})
t.Run("udp", func(t *testing.T) {
t.Run("1-loop", func(t *testing.T) {
runClient(t, "udp", ":9991", &testConf{true, 0, false, false, false, false, 10, RoundRobin})
})
t.Run("N-loop", func(t *testing.T) {
runClient(t, "udp", ":9992", &testConf{true, 0, false, true, false, false, 10, LeastConnections})
})
})
t.Run("udp-async", func(t *testing.T) {
t.Run("1-loop", func(t *testing.T) {
runClient(t, "udp", ":9991", &testConf{true, 0, false, false, true, false, 10, RoundRobin})
})
t.Run("N-loop", func(t *testing.T) {
runClient(t, "udp", ":9992", &testConf{true, 0, false, true, true, false, 10, LeastConnections})
})
})
t.Run("unix", func(t *testing.T) {
t.Run("1-loop", func(t *testing.T) {
runClient(t, "unix", testUnixAddr(t), &testConf{true, 0, false, false, false, false, 10, RoundRobin})
})
t.Run("N-loop", func(t *testing.T) {
runClient(t, "unix", testUnixAddr(t), &testConf{true, 0, false, true, false, false, 10, SourceAddrHash})
})
})
t.Run("unix-async", func(t *testing.T) {
t.Run("1-loop", func(t *testing.T) {
runClient(t, "unix", testUnixAddr(t), &testConf{true, 0, false, false, true, false, 10, RoundRobin})
})
t.Run("N-loop", func(t *testing.T) {
runClient(t, "unix", testUnixAddr(t), &testConf{true, 0, false, true, true, false, 10, SourceAddrHash})
})
})
})
t.Run("poll-ET-chunk", func(t *testing.T) {
t.Run("tcp", func(t *testing.T) {
t.Run("1-loop", func(t *testing.T) {
runClient(t, "tcp", ":9991", &testConf{true, 1 << 18, false, false, false, false, 10, RoundRobin})
})
t.Run("N-loop", func(t *testing.T) {
runClient(t, "tcp", ":9992", &testConf{true, 1 << 19, false, true, false, false, 10, LeastConnections})
})
})
t.Run("tcp-async", func(t *testing.T) {
t.Run("1-loop", func(t *testing.T) {
runClient(t, "tcp", ":9991", &testConf{true, 1 << 18, false, false, true, false, 10, RoundRobin})
})
t.Run("N-loop", func(t *testing.T) {
runClient(t, "tcp", ":9992", &testConf{true, 1 << 19, false, true, true, false, 10, LeastConnections})
})
})
t.Run("udp", func(t *testing.T) {
t.Run("1-loop", func(t *testing.T) {
runClient(t, "udp", ":9991", &testConf{true, 1 << 18, false, false, false, false, 10, RoundRobin})
})
t.Run("N-loop", func(t *testing.T) {
runClient(t, "udp", ":9992", &testConf{true, 1 << 19, false, true, false, false, 10, LeastConnections})
})
})
t.Run("udp-async", func(t *testing.T) {
t.Run("1-loop", func(t *testing.T) {
runClient(t, "udp", ":9991", &testConf{true, 1 << 18, false, false, true, false, 10, RoundRobin})
})
t.Run("N-loop", func(t *testing.T) {
runClient(t, "udp", ":9992", &testConf{true, 1 << 19, false, true, true, false, 10, LeastConnections})
})
})
t.Run("unix", func(t *testing.T) {
t.Run("1-loop", func(t *testing.T) {
runClient(t, "unix", testUnixAddr(t), &testConf{true, 1 << 18, false, false, false, false, 10, RoundRobin})
})
t.Run("N-loop", func(t *testing.T) {
runClient(t, "unix", testUnixAddr(t), &testConf{true, 1 << 19, false, true, false, false, 10, SourceAddrHash})
})
})
t.Run("unix-async", func(t *testing.T) {
t.Run("1-loop", func(t *testing.T) {
runClient(t, "unix", testUnixAddr(t), &testConf{true, 1 << 18, false, false, true, false, 10, RoundRobin})
})
t.Run("N-loop", func(t *testing.T) {
runClient(t, "unix", testUnixAddr(t), &testConf{true, 1 << 19, false, true, true, false, 10, SourceAddrHash})
})
})
})
t.Run("poll-reuseport-LT", func(t *testing.T) {
t.Run("tcp", func(t *testing.T) {
t.Run("1-loop", func(t *testing.T) {
runClient(t, "tcp", ":9991", &testConf{false, 0, true, false, false, false, 10, RoundRobin})
})
t.Run("N-loop", func(t *testing.T) {
runClient(t, "tcp", ":9992", &testConf{false, 0, true, true, false, false, 10, LeastConnections})
})
})
t.Run("tcp-async", func(t *testing.T) {
t.Run("1-loop", func(t *testing.T) {
runClient(t, "tcp", ":9991", &testConf{false, 0, true, false, true, false, 10, RoundRobin})
})
t.Run("N-loop", func(t *testing.T) {
runClient(t, "tcp", ":9992", &testConf{false, 0, true, true, false, false, 10, LeastConnections})
})
})
t.Run("udp", func(t *testing.T) {
t.Run("1-loop", func(t *testing.T) {
runClient(t, "udp", ":9991", &testConf{false, 0, true, false, false, false, 10, RoundRobin})
})
t.Run("N-loop", func(t *testing.T) {
runClient(t, "udp", ":9992", &testConf{false, 0, true, true, false, false, 10, LeastConnections})
})
})
t.Run("udp-async", func(t *testing.T) {
t.Run("1-loop", func(t *testing.T) {
runClient(t, "udp", ":9991", &testConf{false, 0, true, false, false, false, 10, RoundRobin})
})
t.Run("N-loop", func(t *testing.T) {
runClient(t, "udp", ":9992", &testConf{false, 0, true, true, true, false, 10, LeastConnections})
})
})
t.Run("unix", func(t *testing.T) {
t.Run("1-loop", func(t *testing.T) {
runClient(t, "unix", testUnixAddr(t), &testConf{false, 0, true, false, false, false, 10, RoundRobin})
})
t.Run("N-loop", func(t *testing.T) {
runClient(t, "unix", testUnixAddr(t), &testConf{false, 0, true, true, false, false, 10, LeastConnections})
})
})
t.Run("unix-async", func(t *testing.T) {
t.Run("1-loop", func(t *testing.T) {
runClient(t, "unix", testUnixAddr(t), &testConf{false, 0, true, false, true, false, 10, RoundRobin})
})
t.Run("N-loop", func(t *testing.T) {
runClient(t, "unix", testUnixAddr(t), &testConf{false, 0, true, true, true, false, 10, LeastConnections})
})
})
})
t.Run("poll-reuseport-ET", func(t *testing.T) {
t.Run("tcp", func(t *testing.T) {
t.Run("1-loop", func(t *testing.T) {
runClient(t, "tcp", ":9991", &testConf{true, 0, true, false, false, false, 10, RoundRobin})
})
t.Run("N-loop", func(t *testing.T) {
runClient(t, "tcp", ":9992", &testConf{true, 0, true, true, false, false, 10, LeastConnections})
})
})
t.Run("tcp-async", func(t *testing.T) {
t.Run("1-loop", func(t *testing.T) {
runClient(t, "tcp", ":9991", &testConf{true, 0, true, false, true, false, 10, RoundRobin})
})
t.Run("N-loop", func(t *testing.T) {
runClient(t, "tcp", ":9992", &testConf{true, 0, true, true, false, false, 10, LeastConnections})
})
})
t.Run("udp", func(t *testing.T) {
t.Run("1-loop", func(t *testing.T) {
runClient(t, "udp", ":9991", &testConf{true, 0, true, false, false, false, 10, RoundRobin})
})
t.Run("N-loop", func(t *testing.T) {
runClient(t, "udp", ":9992", &testConf{true, 0, true, true, false, false, 10, LeastConnections})
})
})
t.Run("udp-async", func(t *testing.T) {
t.Run("1-loop", func(t *testing.T) {
runClient(t, "udp", ":9991", &testConf{true, 0, true, false, false, false, 10, RoundRobin})
})
t.Run("N-loop", func(t *testing.T) {
runClient(t, "udp", ":9992", &testConf{true, 0, true, true, true, false, 10, LeastConnections})
})
})
t.Run("unix", func(t *testing.T) {
t.Run("1-loop", func(t *testing.T) {
runClient(t, "unix", testUnixAddr(t), &testConf{true, 0, true, false, false, false, 10, RoundRobin})
})
t.Run("N-loop", func(t *testing.T) {
runClient(t, "unix", testUnixAddr(t), &testConf{true, 0, true, true, false, false, 10, LeastConnections})
})
})
t.Run("unix-async", func(t *testing.T) {
t.Run("1-loop", func(t *testing.T) {
runClient(t, "unix", testUnixAddr(t), &testConf{true, 0, true, false, true, false, 10, RoundRobin})
})
t.Run("N-loop", func(t *testing.T) {
runClient(t, "unix", testUnixAddr(t), &testConf{true, 0, true, true, true, false, 10, LeastConnections})
})
})
})
}
type testClient struct {
*BuiltinEventEngine
client *Client
tester *testing.T
eng Engine
network string
addr string
multicore bool
async bool
nclients int
started int32
connected int32
clientActive int32
disconnected int32
udpReadHeader int32
}
func (s *testClient) OnBoot(eng Engine) (action Action) {
s.eng = eng
return
}
func (s *testClient) OnOpen(c Conn) (out []byte, action Action) {
c.SetContext(&sync.Once{})
atomic.AddInt32(&s.connected, 1)
assert.NotNil(s.tester, c.LocalAddr(), "nil local addr")
assert.NotNil(s.tester, c.RemoteAddr(), "nil remote addr")
return
}
func (s *testClient) OnClose(c Conn, err error) (action Action) {
if err != nil {
logging.Debugf("error occurred on closed, %v\n", err)
}
if s.network != "udp" {
assert.IsType(s.tester, c.Context(), new(sync.Once), "invalid context")
}
atomic.AddInt32(&s.disconnected, 1)
if atomic.LoadInt32(&s.connected) == atomic.LoadInt32(&s.disconnected) &&
atomic.LoadInt32(&s.disconnected) == int32(s.nclients) {
action = Shutdown
}
return
}
func (s *testClient) OnShutdown(Engine) {
if s.network == "udp" {
assert.EqualValues(s.tester, int32(s.nclients), atomic.LoadInt32(&s.udpReadHeader))
}
}
func (s *testClient) OnTraffic(c Conn) (action Action) {
readHeader := func() {
ping := make([]byte, len(pingMsg))
n, err := io.ReadFull(c, ping)
assert.NoError(s.tester, err)
assert.EqualValues(s.tester, len(pingMsg), n)
assert.Equal(s.tester, string(pingMsg), string(ping), "bad header")
}
v := c.Context()
if v != nil {
v.(*sync.Once).Do(readHeader)
}
if s.async {
buf := bbPool.Get()
_, err := c.WriteTo(buf)
assert.NoError(s.tester, err, "WriteTo error")
if s.network == "tcp" || s.network == "unix" {
// just for test
_ = c.InboundBuffered()
_ = c.OutboundBuffered()
_, _ = c.Discard(1)
}
if v == nil && bytes.Equal(buf.Bytes(), pingMsg) {
atomic.AddInt32(&s.udpReadHeader, 1)
buf.Reset()
}
err = goPool.DefaultWorkerPool.Submit(
func() {
if buf.Len() > 0 {
err := c.AsyncWrite(buf.Bytes(), nil)
assert.NoError(s.tester, err)
}
})
assert.NoError(s.tester, err)
return
}
buf, err := c.Next(-1)
assert.NoError(s.tester, err, "Reading data error")
if v == nil && bytes.Equal(buf, pingMsg) {
atomic.AddInt32(&s.udpReadHeader, 1)
buf = nil
}
if len(buf) > 0 {
n, err := c.Write(buf)
assert.NoError(s.tester, err)
assert.EqualValues(s.tester, len(buf), n)
}
return
}
func (s *testClient) OnTick() (delay time.Duration, action Action) {
delay = 100 * time.Millisecond
if atomic.CompareAndSwapInt32(&s.started, 0, 1) {
for i := 0; i < s.nclients; i++ {
atomic.AddInt32(&s.clientActive, 1)
var netConn bool
if i%2 == 0 {
netConn = true
}
err := goPool.DefaultWorkerPool.Submit(
func() {
startGnetClient(s.tester, s.client, s.network, s.addr, s.multicore, s.async, netConn)
})
assert.NoError(s.tester, err)
}
}
if s.network == "udp" && atomic.LoadInt32(&s.clientActive) == 0 {
action = Shutdown
return
}
return
}
func runClient(t *testing.T, network, addr string, conf *testConf) {
ts := &testClient{
tester: t,
network: network,
addr: addr,
multicore: conf.multicore,
async: conf.async,
nclients: conf.clients,
}
var err error
clientEV := &clientEvents{tester: t, svr: ts}
ts.client, err = NewClient(
clientEV,
WithMulticore(conf.multicore),
WithEdgeTriggeredIO(conf.et),
WithEdgeTriggeredIOChunk(conf.etChunk),
WithTCPNoDelay(TCPNoDelay),
WithLockOSThread(true),
WithTicker(true),
)
assert.NoError(t, err)
err = ts.client.Start()
assert.NoError(t, err)
defer ts.client.Stop() //nolint:errcheck
err = Run(ts,
network+"://"+addr,
WithEdgeTriggeredIO(conf.et),
WithEdgeTriggeredIOChunk(conf.etChunk),
WithLockOSThread(conf.async),
WithMulticore(conf.multicore),
WithReusePort(conf.reuseport),
WithTicker(true),
WithTCPKeepAlive(time.Minute),
WithTCPKeepInterval(time.Second*10),
WithTCPKeepCount(10),
WithLoadBalancing(conf.lb))
assert.NoError(t, err)
}
func startGnetClient(t *testing.T, cli *Client, network, addr string, multicore, async, netDial bool) {
var (
c Conn
err error
)
handler := &connHandler{
network: network,
rspCh: make(chan []byte, 1),
}
if netDial {
var netConn net.Conn
netConn, err = net.Dial(network, addr)
assert.NoError(t, err)
c, err = cli.EnrollContext(netConn, handler)
} else {
c, err = cli.DialContext(network, addr, handler)
}
assert.NoError(t, err)
defer c.Close() //nolint:errcheck
err = c.Wake(nil)
assert.NoError(t, err)
rspCh := handler.rspCh
duration := time.Duration((rand.Float64()*2+1)*float64(time.Second)) / 2
logging.Debugf("test duration: %v", duration)
start := time.Now()
for time.Since(start) < duration {
reqData := make([]byte, streamLen)
if network == "udp" {
reqData = reqData[:datagramLen]
}
_, err = crand.Read(reqData)
assert.NoError(t, err)
err = c.AsyncWrite(reqData, nil)
assert.NoError(t, err)
respData := <-rspCh
assert.NoError(t, err)
if !async {
// assert.Equalf(t, reqData, respData, "response mismatch with protocol:%s, multi-core:%t, content of bytes: %d vs %d", network, multicore, string(reqData), string(respData))
assert.Equalf(
t,
reqData,
respData,
"response mismatch with protocol:%s, multi-core:%t, length of bytes: %d vs %d",
network,
multicore,
len(reqData),
len(respData),
)
}
}
}
type clientEventsForWake struct {
BuiltinEventEngine
tester *testing.T
ch chan struct{}
}
func (ev *clientEventsForWake) OnBoot(_ Engine) Action {
ev.ch = make(chan struct{})
return None
}
func (ev *clientEventsForWake) OnTraffic(c Conn) (action Action) {
n, err := c.Read(nil)
assert.Zerof(ev.tester, n, "expected: %v, but got: %v", 0, n)
assert.NoErrorf(ev.tester, err, "expected: %v, but got: %v", nil, err)
buf := make([]byte, 10)
n, err = c.Read(buf)
assert.Zerof(ev.tester, n, "expected: %v, but got: %v", 0, n)
assert.ErrorIsf(ev.tester, err, io.ErrShortBuffer, "expected error: %v, but got: %v", io.ErrShortBuffer, err)
buf, err = c.Next(10)
assert.Nilf(ev.tester, buf, "expected: %v, but got: %v", nil, buf)
assert.ErrorIsf(ev.tester, err, io.ErrShortBuffer, "expected error: %v, but got: %v", io.ErrShortBuffer, err)
buf, err = c.Next(-1)
assert.Emptyf(ev.tester, buf, "expected an empty slice, but got: %v", buf)
assert.NoErrorf(ev.tester, err, "expected: %v, but got: %v", nil, err)
buf, err = c.Peek(10)
assert.Nilf(ev.tester, buf, "expected: %v, but got: %v", nil, buf)
assert.ErrorIsf(ev.tester, err, io.ErrShortBuffer, "expected error: %v, but got: %v", io.ErrShortBuffer, err)
buf, err = c.Peek(-1)
assert.Emptyf(ev.tester, buf, "expected an empty slice, but got: %v", buf)
assert.NoErrorf(ev.tester, err, "expected: %v, but got: %v", nil, err)
n, err = c.Discard(10)
assert.Zerof(ev.tester, n, "expected: %v, but got: %v", 0, n)
assert.NoErrorf(ev.tester, err, "expected: %v, but got: %v", nil, err)
n, err = c.Discard(-1)
assert.Zerof(ev.tester, n, "expected: %v, but got: %v", 0, n)
assert.NoErrorf(ev.tester, err, "expected: %v, but got: %v", nil, err)
m, err := c.WriteTo(io.Discard)
assert.Zerof(ev.tester, n, "expected: %v, but got: %v", 0, m)
assert.NoErrorf(ev.tester, err, "expected: %v, but got: %v", nil, err)
n = c.InboundBuffered()
assert.Zerof(ev.tester, n, "expected: %v, but got: %v", 0, m)
<-ev.ch
return None
}
type serverEventsForWake struct {
BuiltinEventEngine
network, addr string
client *Client
clientEV *clientEventsForWake
tester *testing.T
clients int32
started int32
}
func (ev *serverEventsForWake) OnOpen(_ Conn) ([]byte, Action) {
atomic.AddInt32(&ev.clients, 1)
return nil, None
}
func (ev *serverEventsForWake) OnClose(_ Conn, _ error) Action {
if atomic.AddInt32(&ev.clients, -1) == 0 {
return Shutdown
}
return None
}
func (ev *serverEventsForWake) OnTick() (time.Duration, Action) {
if atomic.CompareAndSwapInt32(&ev.started, 0, 1) {
err := goPool.DefaultWorkerPool.Submit(func() {
testConnWakeImmediately(ev.tester, ev.client, ev.clientEV, ev.network, ev.addr)
})
assert.NoError(ev.tester, err)
}
return 100 * time.Millisecond, None
}
func testConnWakeImmediately(t *testing.T, client *Client, clientEV *clientEventsForWake, network, addr string) {
c, err := client.Dial(network, addr)
assert.NoErrorf(t, err, "failed to dial: %v", err)
err = c.Wake(nil)
assert.NoError(t, err)
err = c.Close()
assert.NoError(t, err)
clientEV.ch <- struct{}{}
}
func TestWakeConnImmediately(t *testing.T) {
currentLogger, currentFlusher := logging.GetDefaultLogger(), logging.GetDefaultFlusher()
t.Cleanup(func() {
logging.SetDefaultLoggerAndFlusher(currentLogger, currentFlusher) // restore
})
clientEV := &clientEventsForWake{tester: t}
logPath := filepath.Join(t.TempDir(), "gnet-test-wake-conn-immediately.log")
client, err := NewClient(clientEV,
WithSocketRecvBuffer(4*1024),
WithSocketSendBuffer(4*1024),
WithLogPath(logPath),
WithLogLevel(logging.WarnLevel),
WithReadBufferCap(512),
WithWriteBufferCap(512))
assert.NoError(t, err)
logging.Cleanup()
err = client.Start()
assert.NoError(t, err)
defer client.Stop() //nolint:errcheck
serverEV := &serverEventsForWake{tester: t, network: "tcp", addr: ":18888", client: client, clientEV: clientEV}
err = Run(serverEV, serverEV.network+"://"+serverEV.addr, WithTicker(true))
assert.NoError(t, err)
}
func TestClientReadOnEOF(t *testing.T) {
currentLogger, currentFlusher := logging.GetDefaultLogger(), logging.GetDefaultFlusher()
t.Cleanup(func() {
logging.SetDefaultLoggerAndFlusher(currentLogger, currentFlusher) // restore
})
ln, err := net.Listen("tcp", "127.0.0.1:9999")
assert.NoError(t, err)
defer ln.Close() //nolint:errcheck
err = goPool.DefaultWorkerPool.Submit(func() {
for {
conn, err := ln.Accept()
if err != nil {
break
}
err = goPool.DefaultWorkerPool.Submit(func() {
process(conn)
})
assert.NoError(t, err)
}
})
assert.NoError(t, err)
ev := &clientReadOnEOF{
result: make(chan struct {
data []byte
err error
}, 1),
data: []byte("test"),
}
cli, err := NewClient(ev,
WithSocketRecvBuffer(4*1024),
WithSocketSendBuffer(4*1024),
WithTCPKeepAlive(time.Minute),
WithLogger(zap.NewExample().Sugar()),
WithReadBufferCap(32*1024),
WithWriteBufferCap(32*1024))
assert.NoError(t, err)
defer cli.Stop() //nolint:errcheck
err = cli.Start()
assert.NoError(t, err)
_, err = cli.Dial("tcp", "127.0.0.1:9999")
assert.NoError(t, err)
select {
case res := <-ev.result:
assert.NoError(t, res.err)
assert.EqualValuesf(t, ev.data, res.data, "expected: %v, but got: %v", ev.data, res.data)
case <-time.After(5 * time.Second):
t.Errorf("timeout waiting for the result")
}
}
func process(conn net.Conn) {
defer conn.Close() //nolint:errcheck
buf := make([]byte, 8)
n, err := conn.Read(buf)
if err != nil {
return
}
_, _ = conn.Write(buf[:n])
_ = conn.Close()
}
type clientReadOnEOF struct {
BuiltinEventEngine
data []byte
result chan struct {
data []byte
err error
}
}
func (clientReadOnEOF) OnBoot(Engine) (action Action) {
return None
}
func (cli clientReadOnEOF) OnOpen(Conn) (out []byte, action Action) {
return cli.data, None
}
func (clientReadOnEOF) OnClose(Conn, error) (action Action) {
return Close
}
func (cli clientReadOnEOF) OnTraffic(c Conn) (action Action) {
data, err := c.Next(-1)
cli.result <- struct {
data []byte
err error
}{data: data, err: err}
return None
}
================================================
FILE: client_unix.go
================================================
// Copyright (c) 2021 The Gnet Authors. All rights reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//go:build darwin || dragonfly || freebsd || linux || netbsd || openbsd
package gnet
import (
"context"
"errors"
"net"
"strconv"
"syscall"
"golang.org/x/sync/errgroup"
"golang.org/x/sys/unix"
"github.com/panjf2000/gnet/v2/pkg/buffer/ring"
errorx "github.com/panjf2000/gnet/v2/pkg/errors"
"github.com/panjf2000/gnet/v2/pkg/logging"
"github.com/panjf2000/gnet/v2/pkg/math"
"github.com/panjf2000/gnet/v2/pkg/netpoll"
"github.com/panjf2000/gnet/v2/pkg/queue"
"github.com/panjf2000/gnet/v2/pkg/socket"
)
// Client of gnet.
type Client struct {
opts *Options
eng *engine
}
// NewClient creates an instance of Client.
func NewClient(eh EventHandler, opts ...Option) (cli *Client, err error) {
options := loadOptions(opts...)
cli = new(Client)
cli.opts = options
logger, logFlusher := logging.GetDefaultLogger(), logging.GetDefaultFlusher()
if options.Logger == nil {
if options.LogPath != "" {
logger, logFlusher, _ = logging.CreateLoggerAsLocalFile(options.LogPath, options.LogLevel)
}
options.Logger = logger
} else {
logger = options.Logger
logFlusher = nil
}
logging.SetDefaultLoggerAndFlusher(logger, logFlusher)
rootCtx, shutdown := context.WithCancel(context.Background())
eg, ctx := errgroup.WithContext(rootCtx)
eng := engine{
listeners: make(map[int]*listener),
opts: options,
turnOff: shutdown,
eventHandler: eh,
eventLoops: new(leastConnectionsLoadBalancer),
concurrency: struct {
*errgroup.Group
ctx context.Context
}{eg, ctx},
}
if options.EdgeTriggeredIOChunk > 0 {
options.EdgeTriggeredIO = true
options.EdgeTriggeredIOChunk = math.CeilToPowerOfTwo(options.EdgeTriggeredIOChunk)
} else if options.EdgeTriggeredIO {
options.EdgeTriggeredIOChunk = 1 << 20 // 1MB
}
rbc := options.ReadBufferCap
switch {
case rbc <= 0:
options.ReadBufferCap = MaxStreamBufferCap
case rbc <= ring.DefaultBufferSize:
options.ReadBufferCap = ring.DefaultBufferSize
default:
options.ReadBufferCap = math.CeilToPowerOfTwo(rbc)
}
wbc := options.WriteBufferCap
switch {
case wbc <= 0:
options.WriteBufferCap = MaxStreamBufferCap
case wbc <= ring.DefaultBufferSize:
options.WriteBufferCap = ring.DefaultBufferSize
default:
options.WriteBufferCap = math.CeilToPowerOfTwo(wbc)
}
cli.eng = &eng
return
}
// Start starts the client event-loop, handing IO events.
func (cli *Client) Start() error {
numEventLoop := determineEventLoops(cli.opts)
logging.Infof("Starting gnet client with %d event loops", numEventLoop)
cli.eng.eventHandler.OnBoot(Engine{cli.eng})
var el0 *eventloop
for i := 0; i < numEventLoop; i++ {
p, err := netpoll.OpenPoller()
if err != nil {
cli.eng.closeEventLoops()
return err
}
el := eventloop{
listeners: cli.eng.listeners,
engine: cli.eng,
poller: p,
buffer: make([]byte, cli.opts.ReadBufferCap),
eventHandler: cli.eng.eventHandler,
}
el.connections.init()
cli.eng.eventLoops.register(&el)
if cli.opts.Ticker && el.idx == 0 {
el0 = &el
}
}
cli.eng.eventLoops.iterate(func(_ int, el *eventloop) bool {
cli.eng.concurrency.Go(el.run)
return true
})
// Start the ticker.
if el0 != nil {
ctx := cli.eng.concurrency.ctx
cli.eng.concurrency.Go(func() error {
el0.ticker(ctx)
return nil
})
}
logging.Debugf("default logging level is %s", logging.LogLevel())
return nil
}
// Stop stops the client event-loop.
func (cli *Client) Stop() error {
cli.eng.shutdown(nil)
cli.eng.eventHandler.OnShutdown(Engine{cli.eng})
// Notify all event-loops to exit.
cli.eng.eventLoops.iterate(func(_ int, el *eventloop) bool {
logging.Error(el.poller.Trigger(queue.HighPriority,
func(_ any) error { return errorx.ErrEngineShutdown }, nil))
return true
})
// Wait for all event-loops to exit.
err := cli.eng.concurrency.Wait()
cli.eng.closeEventLoops()
// Put the engine into the shutdown state.
cli.eng.inShutdown.Store(true)
// Flush the logger.
logging.Cleanup()
return err
}
// Dial is like net.Dial().
func (cli *Client) Dial(network, address string) (Conn, error) {
return cli.DialContext(network, address, nil)
}
// DialContext is like Dial but also accepts an empty interface ctx that can be obtained later via Conn.Context.
func (cli *Client) DialContext(network, address string, ctx any) (Conn, error) {
c, err := net.Dial(network, address)
if err != nil {
return nil, err
}
return cli.EnrollContext(c, ctx)
}
// Enroll converts a net.Conn to gnet.Conn and then adds it into the Client.
func (cli *Client) Enroll(c net.Conn) (Conn, error) {
return cli.EnrollContext(c, nil)
}
// EnrollContext is like Enroll but also accepts an empty interface ctx that can be obtained later via Conn.Context.
func (cli *Client) EnrollContext(c net.Conn, ctx any) (Conn, error) {
defer c.Close() //nolint:errcheck
sc, ok := c.(syscall.Conn)
if !ok {
return nil, errors.New("failed to convert net.Conn to syscall.Conn")
}
rc, err := sc.SyscallConn()
if err != nil {
return nil, errors.New("failed to get syscall.RawConn from net.Conn")
}
var dupFD int
e := rc.Control(func(fd uintptr) {
dupFD, err = socket.Dup(int(fd))
})
if err != nil {
return nil, err
}
if e != nil {
return nil, e
}
if cli.opts.SocketSendBuffer > 0 {
if err = socket.SetSendBuffer(dupFD, cli.opts.SocketSendBuffer); err != nil {
return nil, err
}
}
if cli.opts.SocketRecvBuffer > 0 {
if err = socket.SetRecvBuffer(dupFD, cli.opts.SocketRecvBuffer); err != nil {
return nil, err
}
}
el := cli.eng.eventLoops.next(nil)
var (
sockAddr unix.Sockaddr
gc *conn
)
switch c.(type) {
case *net.UnixConn:
sockAddr, _, _, err = socket.GetUnixSockAddr(c.RemoteAddr().Network(), c.RemoteAddr().String())
if err != nil {
return nil, err
}
ua := c.LocalAddr().(*net.UnixAddr)
ua.Name = c.RemoteAddr().String() + "." + strconv.Itoa(dupFD)
gc = newStreamConn("unix", dupFD, el, sockAddr, c.LocalAddr(), c.RemoteAddr())
case *net.TCPConn:
if cli.opts.TCPNoDelay == TCPNoDelay {
if err = socket.SetNoDelay(dupFD, 1); err != nil {
return nil, err
}
}
if cli.opts.TCPKeepAlive > 0 {
if err = setKeepAlive(
dupFD,
true,
cli.opts.TCPKeepAlive,
cli.opts.TCPKeepInterval,
cli.opts.TCPKeepCount); err != nil {
return nil, err
}
}
sockAddr, _, _, _, err = socket.GetTCPSockAddr(c.RemoteAddr().Network(), c.RemoteAddr().String())
if err != nil {
return nil, err
}
gc = newStreamConn("tcp", dupFD, el, sockAddr, c.LocalAddr(), c.RemoteAddr())
case *net.UDPConn:
sockAddr, _, _, _, err = socket.GetUDPSockAddr(c.RemoteAddr().Network(), c.RemoteAddr().String())
if err != nil {
return nil, err
}
gc = newUDPConn(dupFD, el, c.LocalAddr(), sockAddr, true)
default:
return nil, errorx.ErrUnsupportedProtocol
}
gc.ctx = ctx
connOpened := make(chan struct{})
ccb := &connWithCallback{c: gc, cb: func() {
close(connOpened)
}}
err = el.poller.Trigger(queue.HighPriority, el.register, ccb)
if err != nil {
gc.Close() //nolint:errcheck
return nil, err
}
<-connOpened
return gc, nil
}
================================================
FILE: client_windows.go
================================================
// Copyright (c) 2023 The Gnet Authors. All rights reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
package gnet
import (
"context"
"net"
"golang.org/x/sync/errgroup"
errorx "github.com/panjf2000/gnet/v2/pkg/errors"
"github.com/panjf2000/gnet/v2/pkg/logging"
"github.com/panjf2000/gnet/v2/pkg/pool/goroutine"
)
type Client struct {
opts *Options
eng *engine
}
func NewClient(eh EventHandler, opts ...Option) (cli *Client, err error) {
options := loadOptions(opts...)
cli = &Client{opts: options}
logger, logFlusher := logging.GetDefaultLogger(), logging.GetDefaultFlusher()
if options.Logger == nil {
if options.LogPath != "" {
logger, logFlusher, _ = logging.CreateLoggerAsLocalFile(options.LogPath, options.LogLevel)
}
options.Logger = logger
} else {
logger = options.Logger
logFlusher = nil
}
logging.SetDefaultLoggerAndFlusher(logger, logFlusher)
rootCtx, shutdown := context.WithCancel(context.Background())
eg, ctx := errgroup.WithContext(rootCtx)
eng := engine{
listeners: []*listener{},
opts: options,
turnOff: shutdown,
eventHandler: eh,
eventLoops: new(leastConnectionsLoadBalancer),
concurrency: struct {
*errgroup.Group
ctx context.Context
}{eg, ctx},
}
cli.eng = &eng
return
}
func (cli *Client) Start() error {
numEventLoop := determineEventLoops(cli.opts)
logging.Infof("Starting gnet client with %d event loops", numEventLoop)
cli.eng.eventHandler.OnBoot(Engine{cli.eng})
var el0 *eventloop
for i := 0; i < numEventLoop; i++ {
el := eventloop{
ch: make(chan any, 1024),
eng: cli.eng,
connections: make(map[*conn]struct{}),
eventHandler: cli.eng.eventHandler,
}
cli.eng.eventLoops.register(&el)
cli.eng.concurrency.Go(el.run)
if cli.opts.Ticker && el.idx == 0 {
el0 = &el
}
}
if el0 != nil {
ctx := cli.eng.concurrency.ctx
cli.eng.concurrency.Go(func() error {
el0.ticker(ctx)
return nil
})
}
logging.Debugf("default logging level is %s", logging.LogLevel())
return nil
}
func (cli *Client) Stop() error {
cli.eng.shutdown(nil)
cli.eng.eventHandler.OnShutdown(Engine{cli.eng})
// Notify all event-loops to exit.
cli.eng.closeEventLoops()
// Wait for all event-loops to exit.
err := cli.eng.concurrency.Wait()
// Put the engine into the shutdown state.
cli.eng.inShutdown.Store(true)
// Flush the logger.
logging.Cleanup()
return err
}
func (cli *Client) Dial(network, addr string) (Conn, error) {
return cli.DialContext(network, addr, nil)
}
func (cli *Client) DialContext(network, addr string, ctx any) (Conn, error) {
var (
c net.Conn
err error
)
c, err = net.Dial(network, addr)
if err != nil {
return nil, err
}
return cli.EnrollContext(c, ctx)
}
func (cli *Client) Enroll(nc net.Conn) (gc Conn, err error) {
return cli.EnrollContext(nc, nil)
}
func (cli *Client) EnrollContext(nc net.Conn, ctx any) (gc Conn, err error) {
el := cli.eng.eventLoops.next(nil)
connOpened := make(chan struct{})
switch v := nc.(type) {
case *net.TCPConn:
if cli.opts.TCPNoDelay == TCPNoDelay {
if err = v.SetNoDelay(true); err != nil {
return
}
}
c := newStreamConn(el, nc, ctx)
if opts := cli.opts; opts.TCPKeepAlive > 0 {
idle := opts.TCPKeepAlive
intvl := opts.TCPKeepInterval
if intvl == 0 {
intvl = opts.TCPKeepAlive / 5
}
cnt := opts.TCPKeepCount
if opts.TCPKeepCount == 0 {
cnt = 5
}
if err = c.SetKeepAlive(true, idle, intvl, cnt); err != nil {
return
}
}
el.ch <- &openConn{c: c, cb: func() { close(connOpened) }}
goroutine.DefaultWorkerPool.Submit(func() {
var buffer [0x10000]byte
for {
n, err := nc.Read(buffer[:])
if err != nil {
el.ch <- &netErr{c, err}
return
}
el.ch <- packTCPConn(c, buffer[:n])
}
})
gc = c
case *net.UnixConn:
c := newStreamConn(el, nc, ctx)
el.ch <- &openConn{c: c, cb: func() { close(connOpened) }}
goroutine.DefaultWorkerPool.Submit(func() {
var buffer [0x10000]byte
for {
n, err := nc.Read(buffer[:])
if err != nil {
el.ch <- &netErr{c, err}
return
}
el.ch <- packTCPConn(c, buffer[:n])
}
})
gc = c
case *net.UDPConn:
c := newUDPConn(el, nil, nc, nc.LocalAddr(), nc.RemoteAddr(), ctx)
el.ch <- &openConn{c: c, cb: func() { close(connOpened) }}
goroutine.DefaultWorkerPool.Submit(func() {
var buffer [0x10000]byte
for {
n, err := nc.Read(buffer[:])
if err != nil {
el.ch <- &netErr{c, err}
return
}
c := newUDPConn(el, nil, nc, nc.LocalAddr(), nc.RemoteAddr(), ctx)
el.ch <- packUDPConn(c, buffer[:n])
}
})
gc = c
default:
return nil, errorx.ErrUnsupportedProtocol
}
<-connOpened
return
}
================================================
FILE: conn_map.go
================================================
// Copyright (c) 2023 The Gnet Authors. All rights reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//go:build (darwin || dragonfly || freebsd || linux || netbsd || openbsd) && !gc_opt
package gnet
import (
"sync/atomic"
"github.com/panjf2000/gnet/v2/internal/gfd"
)
type connMatrix struct {
connCount int32
connMap map[int]*conn
}
func (cm *connMatrix) init() {
cm.connMap = make(map[int]*conn)
}
func (cm *connMatrix) iterate(f func(*conn) bool) {
for _, c := range cm.connMap {
if c != nil {
if !f(c) {
return
}
}
}
}
func (cm *connMatrix) incCount(_ int, delta int32) {
atomic.AddInt32(&cm.connCount, delta)
}
func (cm *connMatrix) loadCount() (n int32) {
return atomic.LoadInt32(&cm.connCount)
}
func (cm *connMatrix) addConn(c *conn, index int) {
c.gfd = gfd.NewGFD(c.fd, index, 0, 0)
cm.connMap[c.fd] = c
cm.incCount(0, 1)
}
func (cm *connMatrix) delConn(c *conn) {
delete(cm.connMap, c.fd)
cm.incCount(0, -1)
}
func (cm *connMatrix) getConn(fd int) *conn {
return cm.connMap[fd]
}
/*
func (cm *connMatrix) getConnByGFD(fd gfd.GFD) *conn {
return cm.connMap[fd.Fd()]
}
*/
================================================
FILE: conn_matrix.go
================================================
// Copyright (c) 2023 The Gnet Authors. All rights reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//go:build (darwin || dragonfly || freebsd || linux || netbsd || openbsd) && gc_opt
package gnet
import (
"sync/atomic"
"github.com/panjf2000/gnet/v2/internal/gfd"
)
type connMatrix struct {
disableCompact bool // disable compaction when it is true
connCounts [gfd.ConnMatrixRowMax]int32 // number of active connections in event-loop
row int // next available row index
column int // next available column index
table [gfd.ConnMatrixRowMax][]*conn // connection matrix of *conn, multiple slices
fd2gfd map[int]gfd.GFD // fd -> gfd.GFD
}
func (cm *connMatrix) init() {
cm.fd2gfd = make(map[int]gfd.GFD)
}
func (cm *connMatrix) iterate(f func(*conn) bool) {
cm.disableCompact = true
defer func() { cm.disableCompact = false }()
for _, conns := range cm.table {
for _, c := range conns {
if c != nil {
if !f(c) {
return
}
}
}
}
}
func (cm *connMatrix) incCount(row int, delta int32) {
atomic.AddInt32(&cm.connCounts[row], delta)
}
func (cm *connMatrix) loadCount() (n int32) {
for i := 0; i < len(cm.connCounts); i++ {
n += atomic.LoadInt32(&cm.connCounts[i])
}
return
}
func (cm *connMatrix) addConn(c *conn, index int) {
if cm.row >= gfd.ConnMatrixRowMax {
return
}
if cm.table[cm.row] == nil {
cm.table[cm.row] = make([]*conn, gfd.ConnMatrixColumnMax)
}
c.gfd = gfd.NewGFD(c.fd, index, cm.row, cm.column)
cm.fd2gfd[c.fd] = c.gfd
cm.table[cm.row][cm.column] = c
cm.incCount(cm.row, 1)
if cm.column++; cm.column == gfd.ConnMatrixColumnMax {
cm.row++
cm.column = 0
}
}
func (cm *connMatrix) delConn(c *conn) {
cfd, cgfd := c.fd, c.gfd
delete(cm.fd2gfd, cfd)
cm.incCount(cgfd.ConnMatrixRow(), -1)
if cm.connCounts[cgfd.ConnMatrixRow()] == 0 {
cm.table[cgfd.ConnMatrixRow()] = nil
} else {
cm.table[cgfd.ConnMatrixRow()][cgfd.ConnMatrixColumn()] = nil
}
if cm.row > cgfd.ConnMatrixRow() || cm.column > cgfd.ConnMatrixColumn() {
cm.row, cm.column = cgfd.ConnMatrixRow(), cgfd.ConnMatrixColumn()
}
// Locate the last *conn in table and move it to the deleted location.
if cm.disableCompact || cm.table[cgfd.ConnMatrixRow()] == nil { // the deleted *conn is the last one, do nothing here.
return
}
// Traverse backward to find the first non-empty point in the matrix until we reach the deleted position.
for row := gfd.ConnMatrixRowMax - 1; row >= cgfd.ConnMatrixRow(); row-- {
if cm.connCounts[row] == 0 {
continue
}
columnMin := -1
if row == cgfd.ConnMatrixRow() {
columnMin = cgfd.ConnMatrixColumn()
}
for column := gfd.ConnMatrixColumnMax - 1; column > columnMin; column-- {
if cm.table[row][column] == nil {
continue
}
gFd := cm.table[row][column].gfd
gFd.UpdateIndexes(cgfd.ConnMatrixRow(), cgfd.ConnMatrixColumn())
cm.table[row][column].gfd = gFd
cm.fd2gfd[gFd.Fd()] = gFd
cm.table[cgfd.ConnMatrixRow()][cgfd.ConnMatrixColumn()] = cm.table[row][column]
cm.incCount(row, -1)
cm.incCount(cgfd.ConnMatrixRow(), 1)
if cm.connCounts[row] == 0 {
cm.table[row] = nil
} else {
cm.table[row][column] = nil
}
cm.row, cm.column = row, column
return
}
}
}
func (cm *connMatrix) getConn(fd int) *conn {
gFD, ok := cm.fd2gfd[fd]
if !ok {
return nil
}
if cm.table[gFD.ConnMatrixRow()] == nil {
return nil
}
return cm.table[gFD.ConnMatrixRow()][gFD.ConnMatrixColumn()]
}
/*
func (cm *connMatrix) getConnByGFD(fd gfd.GFD) *conn {
if cm.table[fd.ConnMatrixRow()] == nil {
return nil
}
return cm.table[fd.ConnMatrixRow()][fd.ConnMatrixColumn()]
}
*/
================================================
FILE: conn_matrix_test.go
================================================
//go:build (darwin || dragonfly || freebsd || linux || netbsd || openbsd) && gc_opt
package gnet
import (
"net"
"testing"
"github.com/stretchr/testify/require"
"golang.org/x/sys/unix"
goPool "github.com/panjf2000/gnet/v2/pkg/pool/goroutine"
)
var testVastConns = false
func TestConnMatrix(t *testing.T) {
t.Run("1k-connections", func(t *testing.T) {
testConnMatrix(t, 1000)
})
t.Run("10k-connections", func(t *testing.T) {
testConnMatrix(t, 10000)
})
t.Run("100k-connections", func(t *testing.T) {
if !testVastConns {
t.Skip("skipped because testVastConns is set to false")
}
testConnMatrix(t, 100000)
})
t.Run("1m-connections", func(t *testing.T) {
if !testVastConns {
t.Skip("skipped because testVastConns is set to false")
}
testConnMatrix(t, 1000000)
})
}
const (
actionAdd = iota + 1
actionDel
)
type handleConn struct {
c *conn
action int
}
func testConnMatrix(t *testing.T, n int) {
handleConns := make(chan *handleConn, 1024)
connections := connMatrix{}
connections.init()
el := eventloop{engine: &engine{opts: &Options{}}}
done := make(chan struct{})
err := goPool.DefaultWorkerPool.Submit(func() {
for i := 0; i < n+n/2; i++ {
v := <-handleConns
switch v.action {
case actionAdd:
connections.addConn(v.c, 0)
case actionDel:
connections.delConn(v.c)
}
}
close(done)
})
require.NoError(t, err)
for i := 0; i < n; i++ {
c := newStreamConn("tcp", i, &el, &unix.SockaddrInet4{}, &net.TCPAddr{}, &net.TCPAddr{})
handleConns <- &handleConn{c, actionAdd}
if i%2 == 0 {
_ = goPool.DefaultWorkerPool.Submit(func() {
handleConns <- &handleConn{c, actionDel}
})
}
}
m := n / 2
<-done
if count := connections.loadCount(); count != int32(n)/2 {
t.Fatalf("unexpected conn count %d, expected %d", count, int32(n)/2)
}
for i := 0; i < len(connections.table); i++ {
if connections.connCounts[i] == 0 {
continue
}
for j := 0; j < len(connections.table[i]) && m > 0; j++ {
m--
c := connections.table[i][j]
if c == nil {
t.Fatalf("unexpected nil connection at row %d, column %d", i, j)
}
if c.fd != c.gfd.Fd() {
t.Fatalf("unexpected fd %d, expected fd %d", c.gfd.Fd(), c.fd)
}
if i != c.gfd.ConnMatrixRow() || j != c.gfd.ConnMatrixColumn() {
t.Fatalf("unexpected row %d, column %d, expected row %d, column %d",
c.gfd.ConnMatrixRow(), c.gfd.ConnMatrixColumn(), i, j)
}
gfd, ok := connections.fd2gfd[c.fd]
if !ok {
t.Fatalf("missing gfd for fd %d", c.fd)
}
if gfd != c.gfd {
t.Fatalf("expected gfd: %v, but got gfd: %v", c.gfd, gfd)
}
}
}
t.Log("connMatrix remains compact after many additions and deletions, test done!")
}
================================================
FILE: connection_bsd.go
================================================
// Copyright (c) 2021 The Gnet Authors. All rights reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//go:build darwin || dragonfly || freebsd || netbsd || openbsd
package gnet
import (
"io"
"golang.org/x/sys/unix"
"github.com/panjf2000/gnet/v2/pkg/netpoll"
)
func (c *conn) processIO(_ int, filter netpoll.IOEvent, flags netpoll.IOFlags) (err error) {
el := c.loop
switch filter {
case unix.EVFILT_READ:
err = el.read(c)
case unix.EVFILT_WRITE:
err = el.write(c)
}
// EV_EOF indicates that the remote has closed the connection.
// We check for EV_EOF after processing the read/write event
// to ensure that nothing is left out on this event filter.
if flags&unix.EV_EOF != 0 && c.opened && err == nil {
switch filter {
case unix.EVFILT_READ:
// Received the event of EVFILT_READ|EV_EOF, but the previous eventloop.read
// failed to drain the socket buffer, so we make sure we get it done this time.
c.isEOF = true
err = el.read(c)
case unix.EVFILT_WRITE:
// On macOS, the kqueue in either LT or ET mode will notify with one event for the
// EOF of the TCP remote: EVFILT_READ|EV_ADD|EV_CLEAR|EV_EOF. But for some reason,
// two events will be issued in ET mode for the EOF of the Unix remote in this order:
// 1) EVFILT_WRITE|EV_ADD|EV_CLEAR|EV_EOF, 2) EVFILT_READ|EV_ADD|EV_CLEAR|EV_EOF.
err = el.write(c)
default:
c.outboundBuffer.Release() // don't bother to write to a connection that is already broken
err = el.close(c, io.EOF)
}
}
return
}
================================================
FILE: connection_linux.go
================================================
/*
* Copyright (c) 2021 The Gnet Authors. All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*/
package gnet
import (
"io"
"golang.org/x/sys/unix"
"github.com/panjf2000/gnet/v2/pkg/netpoll"
)
func (c *conn) processIO(_ int, ev netpoll.IOEvent, _ netpoll.IOFlags) error {
el := c.loop
// First check for any unexpected non-IO events.
// For these events we just close the connection directly.
if ev&(netpoll.ErrEvents|unix.EPOLLRDHUP) != 0 && ev&netpoll.ReadWriteEvents == 0 {
c.outboundBuffer.Release() // don't bother to write to a connection that is already broken
return el.close(c, io.EOF)
}
// Secondly, check for EPOLLOUT before EPOLLIN, the former has a higher priority
// than the latter regardless of the aliveness of the current connection:
//
// 1. When the connection is alive and the system is overloaded, we want to
// offload the incoming traffic by writing all pending data back to the remotes
// before continuing to read and handle requests.
// 2. When the connection is dead, we need to try writing any pending data back
// to the remote first and then close the connection.
//
// We perform eventloop.write for EPOLLOUT because it can take good care of either case.
if ev&(netpoll.WriteEvents|netpoll.ErrEvents) != 0 {
if err := el.write(c); err != nil {
return err
}
}
// Check for EPOLLIN before EPOLLRDHUP in case that there are pending data in
// the socket buffer.
if ev&(netpoll.ReadEvents|netpoll.ErrEvents) != 0 {
if err := el.read(c); err != nil {
return err
}
}
// Ultimately, check for EPOLLRDHUP, this event indicates that the remote has
// either closed connection or shut down the writing half of the connection.
if ev&unix.EPOLLRDHUP != 0 && c.opened {
if ev&unix.EPOLLIN == 0 { // unreadable EPOLLRDHUP, close the connection directly
return el.close(c, io.EOF)
}
// Received the event of EPOLLIN|EPOLLRDHUP, but the previous eventloop.read
// failed to drain the socket buffer, so we ensure to get it done this time.
c.isEOF = true
return el.read(c)
}
return nil
}
================================================
FILE: connection_unix.go
================================================
// Copyright (c) 2019 The Gnet Authors. All rights reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//go:build darwin || dragonfly || freebsd || linux || netbsd || openbsd
package gnet
import (
"io"
"net"
"os"
"time"
"golang.org/x/sys/unix"
"github.com/panjf2000/gnet/v2/internal/gfd"
"github.com/panjf2000/gnet/v2/pkg/bs"
"github.com/panjf2000/gnet/v2/pkg/buffer/elastic"
errorx "github.com/panjf2000/gnet/v2/pkg/errors"
gio "github.com/panjf2000/gnet/v2/pkg/io"
"github.com/panjf2000/gnet/v2/pkg/netpoll"
bsPool "github.com/panjf2000/gnet/v2/pkg/pool/byteslice"
"github.com/panjf2000/gnet/v2/pkg/queue"
"github.com/panjf2000/gnet/v2/pkg/socket"
)
type conn struct {
fd int // file descriptor
gfd gfd.GFD // gnet file descriptor
ctx any // user-defined context
remote unix.Sockaddr // remote socket address
proto string // protocol name: "tcp", "udp", or "unix".
localAddr net.Addr // local addr
remoteAddr net.Addr // remote addr
loop *eventloop // connected event-loop
outboundBuffer elastic.Buffer // buffer for data that is eligible to be sent to the remote
pollAttachment netpoll.PollAttachment // connection attachment for poller
inboundBuffer elastic.RingBuffer // buffer for leftover data from the remote
buffer []byte // buffer for the latest bytes
cache []byte // temporary cache for the inbound data
isDatagram bool // UDP protocol
opened bool // connection opened event fired
isEOF bool // whether the connection has reached EOF
}
func newStreamConn(proto string, fd int, el *eventloop, sa unix.Sockaddr, localAddr, remoteAddr net.Addr) (c *conn) {
c = &conn{
fd: fd,
proto: proto,
remote: sa,
loop: el,
localAddr: localAddr,
remoteAddr: remoteAddr,
pollAttachment: netpoll.PollAttachment{FD: fd},
}
c.pollAttachment.Callback = c.processIO
c.outboundBuffer.Reset(el.engine.opts.WriteBufferCap)
return
}
func newUDPConn(fd int, el *eventloop, localAddr net.Addr, sa unix.Sockaddr, connected bool) (c *conn) {
c = &conn{
fd: fd,
proto: "udp",
gfd: gfd.NewGFD(fd, el.idx, 0, 0),
remote: sa,
loop: el,
localAddr: localAddr,
remoteAddr: socket.SockaddrToUDPAddr(sa),
isDatagram: true,
pollAttachment: netpoll.PollAttachment{FD: fd, Callback: el.readUDP},
}
if connected {
c.remote = nil
}
return
}
func (c *conn) release() {
c.opened = false
c.isEOF = false
c.ctx = nil
c.buffer = nil
if addr, ok := c.localAddr.(*net.TCPAddr); ok && len(c.loop.listeners) == 0 && len(addr.Zone) > 0 {
bsPool.Put(bs.StringToBytes(addr.Zone))
}
if addr, ok := c.remoteAddr.(*net.TCPAddr); ok && len(addr.Zone) > 0 {
bsPool.Put(bs.StringToBytes(addr.Zone))
}
if addr, ok := c.localAddr.(*net.UDPAddr); ok && len(c.loop.listeners) == 0 && len(addr.Zone) > 0 {
bsPool.Put(bs.StringToBytes(addr.Zone))
}
if addr, ok := c.remoteAddr.(*net.UDPAddr); ok && len(addr.Zone) > 0 {
bsPool.Put(bs.StringToBytes(addr.Zone))
}
c.localAddr = nil
c.remoteAddr = nil
if !c.isDatagram {
c.remote = nil
c.inboundBuffer.Done()
c.outboundBuffer.Release()
}
}
func (c *conn) open(buf []byte) error {
if c.isDatagram && c.remote == nil {
return unix.Send(c.fd, buf, 0)
}
for {
n, err := unix.Write(c.fd, buf)
if err != nil {
if err == unix.EAGAIN {
_, _ = c.outboundBuffer.Write(buf)
break
}
return err
}
buf = buf[n:]
if len(buf) == 0 {
break
}
}
return nil
}
func (c *conn) write(data []byte) (n int, err error) {
isET := c.loop.engine.opts.EdgeTriggeredIO
n = len(data)
// If there is pending data in outbound buffer,
// the current data ought to be appended to the
// outbound buffer for maintaining the sequence
// of network packets.
if !c.outboundBuffer.IsEmpty() {
_, _ = c.outboundBuffer.Write(data)
return
}
defer func() {
if err != nil {
_ = c.loop.close(c, os.NewSyscallError("write", err))
}
}()
var sent int
loop:
if sent, err = unix.Write(c.fd, data); err != nil {
// A temporary error occurs, append the data to outbound buffer,
// writing it back to the remote in the next round for LT mode.
if err == unix.EAGAIN {
_, err = c.outboundBuffer.Write(data)
if !isET {
err = c.loop.poller.ModReadWrite(&c.pollAttachment, isET)
}
return
}
return 0, err
}
data = data[sent:]
if isET && len(data) > 0 {
goto loop
}
// Failed to send all data back to the remote, buffer the leftover data for the next round.
if len(data) > 0 {
_, _ = c.outboundBuffer.Write(data)
err = c.loop.poller.ModReadWrite(&c.pollAttachment, isET)
}
return
}
func (c *conn) writev(bs [][]byte) (n int, err error) {
isET := c.loop.engine.opts.EdgeTriggeredIO
for _, b := range bs {
n += len(b)
}
// If there is pending data in outbound buffer,
// the current data ought to be appended to the
// outbound buffer for maintaining the sequence
// of network packets.
if !c.outboundBuffer.IsEmpty() {
_, _ = c.outboundBuffer.Writev(bs)
return
}
defer func() {
if err != nil {
_ = c.loop.close(c, os.NewSyscallError("writev", err))
}
}()
remaining := n
var sent int
loop:
if sent, err = gio.Writev(c.fd, bs); err != nil {
// A temporary error occurs, append the data to outbound buffer,
// writing it back to the remote in the next round for LT mode.
if err == unix.EAGAIN {
_, err = c.outboundBuffer.Writev(bs)
if !isET {
err = c.loop.poller.ModReadWrite(&c.pollAttachment, isET)
}
return
}
return 0, err
}
pos := len(bs)
if remaining -= sent; remaining > 0 {
for i := range bs {
bn := len(bs[i])
if sent < bn {
bs[i] = bs[i][sent:]
pos = i
break
}
sent -= bn
}
}
bs = bs[pos:]
if isET && remaining > 0 {
goto loop
}
// Failed to send all data back to the remote, buffer the leftover data for the next round.
if remaining > 0 {
_, _ = c.outboundBuffer.Writev(bs)
err = c.loop.poller.ModReadWrite(&c.pollAttachment, isET)
}
return
}
type asyncWriteHook struct {
callback AsyncCallback
data []byte
}
func (c *conn) asyncWrite(a any) (err error) {
hook := a.(*asyncWriteHook)
defer func() {
if hook.callback != nil {
_ = hook.callback(c, err)
}
}()
if !c.opened {
return net.ErrClosed
}
_, err = c.write(hook.data)
return
}
type asyncWritevHook struct {
callback AsyncCallback
data [][]byte
}
func (c *conn) asyncWritev(a any) (err error) {
hook := a.(*asyncWritevHook)
defer func() {
if hook.callback != nil {
_ = hook.callback(c, err)
}
}()
if !c.opened {
return net.ErrClosed
}
_, err = c.writev(hook.data)
return
}
func (c *conn) sendTo(buf []byte, addr unix.Sockaddr) (n int, err error) {
defer func() {
if err != nil {
n = 0
}
}()
if addr != nil {
return len(buf), unix.Sendto(c.fd, buf, 0, addr)
}
if c.remote == nil { // connected UDP socket of client
return len(buf), unix.Send(c.fd, buf, 0)
}
return len(buf), unix.Sendto(c.fd, buf, 0, c.remote) // unconnected UDP socket of server
}
func (c *conn) resetBuffer() {
c.buffer = c.buffer[:0]
c.inboundBuffer.Reset()
c.inboundBuffer.Done()
}
func (c *conn) Read(p []byte) (n int, err error) {
if c.inboundBuffer.IsEmpty() {
n = copy(p, c.buffer)
c.buffer = c.buffer[n:]
if n == 0 && len(p) > 0 {
err = io.ErrShortBuffer
}
return
}
n, _ = c.inboundBuffer.Read(p)
if n == len(p) {
return
}
m := copy(p[n:], c.buffer)
n += m
c.buffer = c.buffer[m:]
return
}
func (c *conn) Next(n int) (buf []byte, err error) {
inBufferLen := c.inboundBuffer.Buffered()
if totalLen := inBufferLen + len(c.buffer); n > totalLen {
return nil, io.ErrShortBuffer
} else if n <= 0 {
n = totalLen
}
if c.inboundBuffer.IsEmpty() {
buf = c.buffer[:n]
c.buffer = c.buffer[n:]
return
}
buf = bsPool.Get(n)
_, err = c.Read(buf)
return
}
func (c *conn) Peek(n int) (buf []byte, err error) {
inBufferLen := c.inboundBuffer.Buffered()
if totalLen := inBufferLen + len(c.buffer); n > totalLen {
return nil, io.ErrShortBuffer
} else if n <= 0 {
n = totalLen
}
if c.inboundBuffer.IsEmpty() {
return c.buffer[:n], err
}
head, tail := c.inboundBuffer.Peek(n)
if len(head) == n {
return head, err
}
buf = bsPool.Get(n)[:0]
buf = append(buf, head...)
buf = append(buf, tail...)
if inBufferLen >= n {
return
}
remaining := n - inBufferLen
buf = append(buf, c.buffer[:remaining]...)
c.cache = buf
return
}
func (c *conn) Discard(n int) (int, error) {
if len(c.cache) > 0 {
bsPool.Put(c.cache)
c.cache = nil
}
inBufferLen := c.inboundBuffer.Buffered()
if totalLen := inBufferLen + len(c.buffer); n >= totalLen || n <= 0 {
c.resetBuffer()
return totalLen, nil
}
if c.inboundBuffer.IsEmpty() {
c.buffer = c.buffer[n:]
return n, nil
}
discarded, _ := c.inboundBuffer.Discard(n)
if discarded < inBufferLen {
return discarded, nil
}
remaining := n - inBufferLen
c.buffer = c.buffer[remaining:]
return n, nil
}
func (c *conn) Write(p []byte) (int, error) {
if c.isDatagram {
return c.sendTo(p, nil)
}
return c.write(p)
}
func (c *conn) SendTo(p []byte, addr net.Addr) (int, error) {
if !c.isDatagram {
return 0, errorx.ErrUnsupportedOp
}
sa := socket.NetAddrToSockaddr(addr)
if sa == nil {
return 0, errorx.ErrInvalidNetworkAddress
}
return c.sendTo(p, sa)
}
func (c *conn) Writev(bs [][]byte) (int, error) {
if c.isDatagram {
return 0, errorx.ErrUnsupportedOp
}
return c.writev(bs)
}
func (c *conn) ReadFrom(r io.Reader) (int64, error) {
return c.outboundBuffer.ReadFrom(r)
}
func (c *conn) WriteTo(w io.Writer) (n int64, err error) {
if !c.inboundBuffer.IsEmpty() {
if n, err = c.inboundBuffer.WriteTo(w); err != nil {
return
}
}
var m int
m, err = w.Write(c.buffer)
n += int64(m)
c.buffer = c.buffer[m:]
return
}
func (c *conn) Flush() error {
return c.loop.write(c)
}
func (c *conn) InboundBuffered() int {
return c.inboundBuffer.Buffered() + len(c.buffer)
}
func (c *conn) OutboundBuffered() int {
return c.outboundBuffer.Buffered()
}
func (c *conn) Context() any { return c.ctx }
func (c *conn) SetContext(ctx any) { c.ctx = ctx }
func (c *conn) LocalAddr() net.Addr { return c.localAddr }
func (c *conn) RemoteAddr() net.Addr { return c.remoteAddr }
// Implementation of Socket interface
// func (c *conn) Gfd() gfd.GFD { return c.gfd }
func (c *conn) Fd() int { return c.fd }
func (c *conn) Dup() (fd int, err error) { return socket.Dup(c.fd) }
func (c *conn) SetReadBuffer(bytes int) error { return socket.SetRecvBuffer(c.fd, bytes) }
func (c *conn) SetWriteBuffer(bytes int) error { return socket.SetSendBuffer(c.fd, bytes) }
func (c *conn) SetLinger(sec int) error { return socket.SetLinger(c.fd, sec) }
func (c *conn) SetNoDelay(noDelay bool) error {
return socket.SetNoDelay(c.fd, func(b bool) int {
if b {
return 1
}
return 0
}(noDelay))
}
func (c *conn) SetKeepAlivePeriod(d time.Duration) error {
if c.proto != "tcp" {
return errorx.ErrUnsupportedOp
}
return socket.SetKeepAlivePeriod(c.fd, int(d.Seconds()))
}
func (c *conn) SetKeepAlive(enabled bool, idle, intvl time.Duration, cnt int) error {
if c.proto != "tcp" {
return errorx.ErrUnsupportedOp
}
return socket.SetKeepAlive(c.fd, enabled, int(idle.Seconds()), int(intvl.Seconds()), cnt)
}
func (c *conn) AsyncWrite(buf []byte, callback AsyncCallback) error {
if c.isDatagram {
_, err := c.sendTo(buf, nil)
// TODO: it will not go asynchronously with UDP, so calling a callback is needless,
// we may remove this branch in the future, please don't rely on the callback
// to do something important under UDP, if you're working with UDP, just call Conn.Write
// to send back your data.
if callback != nil {
_ = callback(nil, nil)
}
return err
}
return c.loop.poller.Trigger(queue.HighPriority, c.asyncWrite, &asyncWriteHook{callback, buf})
}
func (c *conn) AsyncWritev(bs [][]byte, callback AsyncCallback) error {
if c.isDatagram {
return errorx.ErrUnsupportedOp
}
return c.loop.poller.Trigger(queue.HighPriority, c.asyncWritev, &asyncWritevHook{callback, bs})
}
func (c *conn) Wake(callback AsyncCallback) error {
return c.loop.poller.Trigger(queue.LowPriority, func(_ any) (err error) {
err = c.loop.wake(c)
if callback != nil {
_ = callback(c, err)
}
return
}, nil)
}
func (c *conn) CloseWithCallback(callback AsyncCallback) error {
return c.loop.poller.Trigger(queue.LowPriority, func(_ any) (err error) {
err = c.loop.close(c, nil)
if callback != nil {
_ = callback(c, err)
}
return
}, nil)
}
func (c *conn) Close() error {
return c.loop.poller.Trigger(queue.LowPriority, func(_ any) (err error) {
err = c.loop.close(c, nil)
return
}, nil)
}
func (c *conn) EventLoop() EventLoop {
return c.loop
}
func (*conn) SetDeadline(_ time.Time) error {
return errorx.ErrUnsupportedOp
}
func (*conn) SetReadDeadline(_ time.Time) error {
return errorx.ErrUnsupportedOp
}
func (*conn) SetWriteDeadline(_ time.Time) error {
return errorx.ErrUnsupportedOp
}
================================================
FILE: connection_windows.go
================================================
// Copyright (c) 2023 The Gnet Authors. All rights reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
package gnet
import (
"errors"
"io"
"net"
"os"
"syscall"
"time"
"golang.org/x/sys/windows"
"github.com/panjf2000/gnet/v2/pkg/buffer/elastic"
errorx "github.com/panjf2000/gnet/v2/pkg/errors"
bbPool "github.com/panjf2000/gnet/v2/pkg/pool/bytebuffer"
bsPool "github.com/panjf2000/gnet/v2/pkg/pool/byteslice"
"github.com/panjf2000/gnet/v2/pkg/pool/goroutine"
)
type netErr struct {
c *conn
err error
}
type tcpConn struct {
c *conn
b *bbPool.ByteBuffer
}
type udpConn struct {
c *conn
}
type openConn struct {
c *conn
cb func()
}
type conn struct {
pc net.PacketConn
ctx any // user-defined context
loop *eventloop // owner event-loop
buffer *bbPool.ByteBuffer // reuse memory of inbound data as a temporary buffer
cache []byte // temporary cache for the inbound data
rawConn net.Conn // original connection
localAddr net.Addr // local server addr
remoteAddr net.Addr // remote addr
inboundBuffer elastic.RingBuffer // buffer for data from the remote
}
func packTCPConn(c *conn, buf []byte) *tcpConn {
b := bbPool.Get()
_, _ = b.Write(buf)
return &tcpConn{c: c, b: b}
}
func unpackTCPConn(tc *tcpConn) *conn {
if tc.c.buffer == nil { // the connection has been closed
return nil
}
_, _ = tc.c.buffer.Write(tc.b.B)
bbPool.Put(tc.b)
tc.b = nil
return tc.c
}
func packUDPConn(c *conn, buf []byte) *udpConn {
_, _ = c.buffer.Write(buf)
return &udpConn{c}
}
func newStreamConn(el *eventloop, nc net.Conn, ctx any) (c *conn) {
return &conn{
ctx: ctx,
loop: el,
buffer: bbPool.Get(),
rawConn: nc,
localAddr: nc.LocalAddr(),
remoteAddr: nc.RemoteAddr(),
}
}
func (c *conn) release() {
c.ctx = nil
c.localAddr = nil
if c.rawConn != nil {
c.rawConn = nil
c.remoteAddr = nil
}
c.inboundBuffer.Done()
bbPool.Put(c.buffer)
c.buffer = nil
}
func newUDPConn(el *eventloop, pc net.PacketConn, rc net.Conn, localAddr, remoteAddr net.Addr, ctx any) *conn {
return &conn{
ctx: ctx,
pc: pc,
rawConn: rc,
loop: el,
buffer: bbPool.Get(),
localAddr: localAddr,
remoteAddr: remoteAddr,
}
}
func (c *conn) resetBuffer() {
c.buffer.Reset()
c.inboundBuffer.Reset()
c.inboundBuffer.Done()
}
func (c *conn) Read(p []byte) (n int, err error) {
if c.inboundBuffer.IsEmpty() {
n = copy(p, c.buffer.B)
c.buffer.B = c.buffer.B[n:]
if n == 0 && len(p) > 0 {
err = io.ErrShortBuffer
}
return
}
n, _ = c.inboundBuffer.Read(p)
if n == len(p) {
return
}
m := copy(p[n:], c.buffer.B)
n += m
c.buffer.B = c.buffer.B[m:]
return
}
func (c *conn) Next(n int) (buf []byte, err error) {
inBufferLen := c.inboundBuffer.Buffered()
if totalLen := inBufferLen + c.buffer.Len(); n > totalLen {
return nil, io.ErrShortBuffer
} else if n <= 0 {
n = totalLen
}
if c.inboundBuffer.IsEmpty() {
buf = c.buffer.B[:n]
c.buffer.B = c.buffer.B[n:]
return
}
buf = bsPool.Get(n)
_, err = c.Read(buf)
return
}
func (c *conn) Peek(n int) (buf []byte, err error) {
inBufferLen := c.inboundBuffer.Buffered()
if totalLen := inBufferLen + c.buffer.Len(); n > totalLen {
return nil, io.ErrShortBuffer
} else if n <= 0 {
n = totalLen
}
if c.inboundBuffer.IsEmpty() {
return c.buffer.B[:n], err
}
head, tail := c.inboundBuffer.Peek(n)
if len(head) == n {
return head, err
}
buf = bsPool.Get(n)[:0]
buf = append(buf, head...)
buf = append(buf, tail...)
if inBufferLen >= n {
return
}
remaining := n - inBufferLen
buf = append(buf, c.buffer.B[:remaining]...)
c.cache = buf
return
}
func (c *conn) Discard(n int) (int, error) {
if len(c.cache) > 0 {
bsPool.Put(c.cache)
c.cache = nil
}
inBufferLen := c.inboundBuffer.Buffered()
if totalLen := inBufferLen + c.buffer.Len(); n >= totalLen || n <= 0 {
c.resetBuffer()
return totalLen, nil
}
if c.inboundBuffer.IsEmpty() {
c.buffer.B = c.buffer.B[n:]
return n, nil
}
discarded, _ := c.inboundBuffer.Discard(n)
if discarded < inBufferLen {
return discarded, nil
}
remaining := n - inBufferLen
c.buffer.B = c.buffer.B[remaining:]
return n, nil
}
func (c *conn) Write(p []byte) (int, error) {
if c.rawConn == nil && c.pc == nil {
return 0, net.ErrClosed
}
if c.rawConn != nil {
return c.rawConn.Write(p)
}
return c.pc.WriteTo(p, c.remoteAddr)
}
func (c *conn) SendTo(p []byte, addr net.Addr) (int, error) {
if c.pc == nil {
return 0, errorx.ErrUnsupportedOp
}
if addr == nil {
return 0, errorx.ErrInvalidNetworkAddress
}
return c.pc.WriteTo(p, addr)
}
func (c *conn) Writev(bs [][]byte) (int, error) {
if c.pc != nil { // not available for UDP
return 0, errorx.ErrUnsupportedOp
}
if c.rawConn != nil {
bb := bbPool.Get()
defer bbPool.Put(bb)
for i := range bs {
_, _ = bb.Write(bs[i])
}
return c.rawConn.Write(bb.Bytes())
}
return 0, net.ErrClosed
}
func (c *conn) ReadFrom(r io.Reader) (int64, error) {
if c.rawConn != nil {
return io.Copy(c.rawConn, r)
}
return 0, net.ErrClosed
}
func (c *conn) WriteTo(w io.Writer) (n int64, err error) {
if !c.inboundBuffer.IsEmpty() {
if n, err = c.inboundBuffer.WriteTo(w); err != nil {
return
}
}
if c.buffer == nil {
return 0, nil
}
defer c.buffer.Reset()
return c.buffer.WriteTo(w)
}
func (c *conn) Flush() error {
return nil
}
func (c *conn) InboundBuffered() int {
if c.buffer == nil {
return 0
}
return c.inboundBuffer.Buffered() + c.buffer.Len()
}
func (c *conn) OutboundBuffered() int {
return 0
}
func (c *conn) Context() any { return c.ctx }
func (c *conn) SetContext(ctx any) { c.ctx = ctx }
func (c *conn) LocalAddr() net.Addr { return c.localAddr }
func (c *conn) RemoteAddr() net.Addr { return c.remoteAddr }
func (c *conn) Fd() (fd int) {
if c.rawConn == nil {
return -1
}
rc, err := c.rawConn.(syscall.Conn).SyscallConn()
if err != nil {
return -1
}
if err := rc.Control(func(i uintptr) {
fd = int(i)
}); err != nil {
return -1
}
return
}
func (c *conn) Dup() (fd int, err error) {
if c.rawConn == nil && c.pc == nil {
return -1, net.ErrClosed
}
var (
sc syscall.Conn
ok bool
)
if c.rawConn != nil {
sc, ok = c.rawConn.(syscall.Conn)
} else {
sc, ok = c.pc.(syscall.Conn)
}
if !ok {
return -1, errors.New("failed to convert net.Conn to syscall.Conn")
}
rc, err := sc.SyscallConn()
if err != nil {
return -1, errors.New("failed to get syscall.RawConn from net.Conn")
}
var dupHandle windows.Handle
e := rc.Control(func(fd uintptr) {
process := windows.CurrentProcess()
err = windows.DuplicateHandle(
process,
windows.Handle(fd),
process,
&dupHandle,
0,
true,
windows.DUPLICATE_SAME_ACCESS,
)
})
if err != nil {
return -1, err
}
if e != nil {
return -1, e
}
return int(dupHandle), nil
}
func (c *conn) SetReadBuffer(bytes int) error {
if c.rawConn == nil && c.pc == nil {
return net.ErrClosed
}
if c.rawConn != nil {
return c.rawConn.(interface{ SetReadBuffer(int) error }).SetReadBuffer(bytes)
}
return c.pc.(interface{ SetReadBuffer(int) error }).SetReadBuffer(bytes)
}
func (c *conn) SetWriteBuffer(bytes int) error {
if c.rawConn == nil && c.pc == nil {
return net.ErrClosed
}
if c.rawConn != nil {
return c.rawConn.(interface{ SetWriteBuffer(int) error }).SetWriteBuffer(bytes)
}
return c.pc.(interface{ SetWriteBuffer(int) error }).SetWriteBuffer(bytes)
}
func (c *conn) SetLinger(sec int) error {
if c.rawConn == nil {
return net.ErrClosed
}
tc, ok := c.rawConn.(*net.TCPConn)
if !ok {
return errorx.ErrUnsupportedOp
}
return tc.SetLinger(sec)
}
func (c *conn) SetNoDelay(noDelay bool) error {
if c.rawConn == nil {
return net.ErrClosed
}
tc, ok := c.rawConn.(*net.TCPConn)
if !ok {
return errorx.ErrUnsupportedOp
}
return tc.SetNoDelay(noDelay)
}
func (c *conn) SetKeepAlivePeriod(d time.Duration) error {
return c.SetKeepAlive(d > 0, d, d/5, 5)
}
func (c *conn) SetKeepAlive(enabled bool, idle, intvl time.Duration, cnt int) error {
if c.rawConn == nil && c.pc == nil {
return net.ErrClosed
}
if c.pc != nil {
return errorx.ErrUnsupportedOp
}
tc, ok := c.rawConn.(*net.TCPConn)
if !ok {
return errorx.ErrUnsupportedOp
}
if enabled && (idle <= 0 || intvl <= 0 || cnt <= 0) {
return errors.New("invalid time duration")
}
if err := tc.SetKeepAlive(enabled); err != nil {
return err
}
if !enabled {
return nil
}
if err := tc.SetKeepAlivePeriod(idle); err != nil {
return err
}
if err := windows.SetsockoptInt(
windows.Handle(c.Fd()),
windows.IPPROTO_TCP,
windows.TCP_KEEPINTVL,
int(intvl.Seconds())); err != nil {
return os.NewSyscallError("setsockopt", err)
}
if err := windows.SetsockoptInt(
windows.Handle(c.Fd()),
windows.IPPROTO_TCP,
windows.TCP_KEEPCNT,
cnt); err != nil {
return os.NewSyscallError("setsockopt", err)
}
return nil
}
// Gfd return an uninitialized GFD which is not valid,
// this method is only implemented for compatibility, don't use it on Windows.
// func (c *conn) Gfd() gfd.GFD { return gfd.GFD{} }
func (c *conn) AsyncWrite(buf []byte, cb AsyncCallback) error {
fn := func() error {
_, err := c.Write(buf)
if cb != nil {
_ = cb(c, err)
}
return err
}
var err error
select {
case c.loop.ch <- fn:
default:
// If the event-loop channel is full, asynchronize this operation to avoid blocking the eventloop.
err = goroutine.DefaultWorkerPool.Submit(func() {
c.loop.ch <- fn
})
}
return err
}
func (c *conn) AsyncWritev(bs [][]byte, cb AsyncCallback) error {
if c.pc != nil {
return errorx.ErrUnsupportedOp
}
buf := bbPool.Get()
for _, b := range bs {
_, _ = buf.Write(b)
}
return c.AsyncWrite(buf.Bytes(), func(c Conn, err error) error {
defer bbPool.Put(buf)
if cb == nil {
return err
}
return cb(c, err)
})
}
func (c *conn) Wake(cb AsyncCallback) (err error) {
wakeFn := func() (err error) {
err = c.loop.wake(c)
if cb != nil {
_ = cb(c, err)
}
return
}
select {
case c.loop.ch <- wakeFn:
default:
// If the event-loop channel is full, asynchronize this operation to avoid blocking the eventloop.
err = goroutine.DefaultWorkerPool.Submit(func() {
c.loop.ch <- wakeFn
})
}
return
}
func (c *conn) Close() (err error) {
closeFn := func() error {
return c.loop.close(c, nil)
}
select {
case c.loop.ch <- closeFn:
default:
// If the event-loop channel is full, asynchronize this operation to avoid blocking the eventloop.
err = goroutine.DefaultWorkerPool.Submit(func() {
c.loop.ch <- closeFn
})
}
return
}
func (c *conn) CloseWithCallback(cb AsyncCallback) (err error) {
closeFn := func() (err error) {
err = c.loop.close(c, nil)
if cb != nil {
_ = cb(c, err)
}
return
}
select {
case c.loop.ch <- closeFn:
default:
// If the event-loop channel is full, asynchronize this operation to avoid blocking the eventloop.
err = goroutine.DefaultWorkerPool.Submit(func() {
c.loop.ch <- closeFn
})
}
return
}
func (c *conn) EventLoop() EventLoop {
return c.loop
}
func (*conn) SetDeadline(_ time.Time) error {
return errorx.ErrUnsupportedOp
}
func (*conn) SetReadDeadline(_ time.Time) error {
return errorx.ErrUnsupportedOp
}
func (*conn) SetWriteDeadline(_ time.Time) error {
return errorx.ErrUnsupportedOp
}
================================================
FILE: context.go
================================================
/*
* Copyright (c) 2025 The Gnet Authors. All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package gnet
import (
"context"
"net"
)
// contextKey is a key for Conn values in context.Context.
type contextKey struct{}
// NewContext returns a new context.Context that carries the value
// that will be attached to the Conn.
func NewContext(ctx context.Context, v any) context.Context {
return context.WithValue(ctx, contextKey{}, v)
}
// FromContext retrieves context value of the Conn stored in ctx, if any.
func FromContext(ctx context.Context) any {
return ctx.Value(contextKey{})
}
// connContextKey is a key for net.Conn values in context.Context.
type connContextKey struct{}
// NewNetConnContext returns a new context.Context that carries the net.Conn value.
func NewNetConnContext(ctx context.Context, c net.Conn) context.Context {
return context.WithValue(ctx, connContextKey{}, c)
}
// FromNetConnContext retrieves the net.Conn value from ctx, if any.
func FromNetConnContext(ctx context.Context) (net.Conn, bool) {
c, ok := ctx.Value(connContextKey{}).(net.Conn)
return c, ok
}
// netAddrContextKey is a key for net.Addr values in context.Context.
type netAddrContextKey struct{}
// NewNetAddrContext returns a new context.Context that carries the net.Addr value.
func NewNetAddrContext(ctx context.Context, a net.Addr) context.Context {
return context.WithValue(ctx, netAddrContextKey{}, a)
}
// FromNetAddrContext retrieves the net.Addr value from ctx, if any.
func FromNetAddrContext(ctx context.Context) (net.Addr, bool) {
a, ok := ctx.Value(netAddrContextKey{}).(net.Addr)
return a, ok
}
================================================
FILE: engine_unix.go
================================================
// Copyright (c) 2019 The Gnet Authors. All rights reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//go:build darwin || dragonfly || freebsd || linux || netbsd || openbsd
package gnet
import (
"context"
"errors"
"strings"
"sync/atomic"
"time"
"golang.org/x/sync/errgroup"
errorx "github.com/panjf2000/gnet/v2/pkg/errors"
"github.com/panjf2000/gnet/v2/pkg/logging"
"github.com/panjf2000/gnet/v2/pkg/netpoll"
"github.com/panjf2000/gnet/v2/pkg/queue"
"github.com/panjf2000/gnet/v2/pkg/socket"
)
type engine struct {
listeners map[int]*listener // listeners for accepting incoming connections
opts *Options // options with engine
ingress *eventloop // main event-loop that monitors all listeners
eventLoops loadBalancer // event-loops for handling events
inShutdown atomic.Bool // whether the engine is in shutdown
turnOff context.CancelFunc
eventHandler EventHandler // user eventHandler
concurrency struct {
*errgroup.Group
ctx context.Context
}
}
func (eng *engine) isShutdown() bool {
return eng.inShutdown.Load()
}
// shutdown signals the engine to shut down.
func (eng *engine) shutdown(err error) {
if err != nil && !errors.Is(err, errorx.ErrEngineShutdown) {
eng.opts.Logger.Errorf("engine is being shutdown with error: %v", err)
}
// Cancel the context to stop the engine.
eng.turnOff()
}
func (eng *engine) closeEventLoops() {
eng.eventLoops.iterate(func(_ int, el *eventloop) bool {
for _, ln := range el.listeners {
ln.close()
}
_ = el.poller.Close()
return true
})
if eng.ingress != nil {
for _, ln := range eng.listeners {
ln.close()
}
err := eng.ingress.poller.Close()
if err != nil {
eng.opts.Logger.Errorf("failed to close poller when stopping engine: %v", err)
}
}
}
func (eng *engine) runEventLoops(ctx context.Context, numEventLoop int) error {
var el0 *eventloop
lns := eng.listeners
// Create loops locally and bind the listeners.
for i := 0; i < numEventLoop; i++ {
if i > 0 {
lns = make(map[int]*listener, len(eng.listeners))
for _, l := range eng.listeners {
ln, err := initListener(l.network, l.address, eng.opts)
if err != nil {
return err
}
lns[ln.fd] = ln
}
}
p, err := netpoll.OpenPoller()
if err != nil {
return err
}
el := new(eventloop)
el.listeners = lns
el.engine = eng
el.poller = p
el.buffer = make([]byte, eng.opts.ReadBufferCap)
el.connections.init()
el.eventHandler = eng.eventHandler
for _, ln := range lns {
if err = el.poller.AddRead(ln.packPollAttachment(el.accept), false); err != nil {
return err
}
}
eng.eventLoops.register(el)
// Start the ticker.
if eng.opts.Ticker && el.idx == 0 {
el0 = el
}
}
// Start event-loops in the background.
eng.eventLoops.iterate(func(_ int, el *eventloop) bool {
eng.concurrency.Go(el.run)
return true
})
if el0 != nil {
eng.concurrency.Go(func() error {
el0.ticker(ctx)
return nil
})
}
return nil
}
func (eng *engine) activateReactors(ctx context.Context, numEventLoop int) error {
for i := 0; i < numEventLoop; i++ {
p, err := netpoll.OpenPoller()
if err != nil {
return err
}
el := new(eventloop)
el.listeners = eng.listeners
el.engine = eng
el.poller = p
el.buffer = make([]byte, eng.opts.ReadBufferCap)
el.connections.init()
el.eventHandler = eng.eventHandler
eng.eventLoops.register(el)
}
// Start sub reactors in the background.
eng.eventLoops.iterate(func(_ int, el *eventloop) bool {
eng.concurrency.Go(el.orbit)
return true
})
p, err := netpoll.OpenPoller()
if err != nil {
return err
}
el := new(eventloop)
el.listeners = eng.listeners
el.idx = -1
el.engine = eng
el.poller = p
el.eventHandler = eng.eventHandler
for _, ln := range eng.listeners {
if err = el.poller.AddRead(ln.packPollAttachment(el.accept0), true); err != nil {
return err
}
}
eng.ingress = el
// Start the main reactor in the background.
eng.concurrency.Go(el.rotate)
// Start the ticker.
if eng.opts.Ticker {
eng.concurrency.Go(func() error {
eng.ingress.ticker(ctx)
return nil
})
}
return nil
}
func (eng *engine) start(ctx context.Context, numEventLoop int) error {
if eng.opts.ReusePort {
return eng.runEventLoops(ctx, numEventLoop)
}
return eng.activateReactors(ctx, numEventLoop)
}
func (eng *engine) stop(ctx context.Context, s Engine) {
// Wait on a signal for shutdown
<-ctx.Done()
eng.eventHandler.OnShutdown(s)
// Notify all event-loops to exit.
eng.eventLoops.iterate(func(i int, el *eventloop) bool {
err := el.poller.Trigger(queue.HighPriority, func(_ any) error { return errorx.ErrEngineShutdown }, nil)
if err != nil {
eng.opts.Logger.Errorf("failed to enqueue shutdown signal of high-priority for event-loop(%d): %v", i, err)
}
return true
})
if eng.ingress != nil {
err := eng.ingress.poller.Trigger(queue.HighPriority, func(_ any) error { return errorx.ErrEngineShutdown }, nil)
if err != nil {
eng.opts.Logger.Errorf("failed to enqueue shutdown signal of high-priority for main event-loop: %v", err)
}
}
if err := eng.concurrency.Wait(); err != nil {
eng.opts.Logger.Errorf("engine shutdown error: %v", err)
}
// Close all listeners and pollers of event-loops.
eng.closeEventLoops()
// Put the engine into the shutdown state.
eng.inShutdown.Store(true)
}
func run(eventHandler EventHandler, listeners []*listener, options *Options, addrs []string) error {
numEventLoop := determineEventLoops(options)
logging.Infof("Launching gnet with %d event-loops, listening on: %s",
numEventLoop, strings.Join(addrs, " | "))
lns := make(map[int]*listener, len(listeners))
for _, ln := range listeners {
lns[ln.fd] = ln
}
rootCtx, shutdown := context.WithCancel(context.Background())
eg, ctx := errgroup.WithContext(rootCtx)
eng := engine{
listeners: lns,
opts: options,
turnOff: shutdown,
eventHandler: eventHandler,
concurrency: struct {
*errgroup.Group
ctx context.Context
}{eg, ctx},
}
switch options.LB {
case RoundRobin:
eng.eventLoops = new(roundRobinLoadBalancer)
case LeastConnections:
eng.eventLoops = new(leastConnectionsLoadBalancer)
case SourceAddrHash:
eng.eventLoops = new(sourceAddrHashLoadBalancer)
}
e := Engine{&eng}
switch eng.eventHandler.OnBoot(e) {
case None, Close:
case Shutdown:
return nil
}
if err := eng.start(ctx, numEventLoop); err != nil {
eng.closeEventLoops()
eng.opts.Logger.Errorf("gnet engine is stopping with error: %v", err)
return err
}
defer eng.stop(rootCtx, e)
for _, addr := range addrs {
allEngines.Store(addr, &eng)
}
return nil
}
func setKeepAlive(fd int, enabled bool, idle, intvl time.Duration, cnt int) error {
if intvl == 0 {
intvl = idle / 5
}
if cnt == 0 {
cnt = 5
}
return socket.SetKeepAlive(fd, enabled, int(idle.Seconds()), int(intvl.Seconds()), cnt)
}
/*
func (eng *engine) sendCmd(cmd *asyncCmd, urgent bool) error {
if !gfd.Validate(cmd.fd) {
return errors.ErrInvalidConn
}
el := eng.eventLoops.index(cmd.fd.EventLoopIndex())
if el == nil {
return errors.ErrInvalidConn
}
if urgent {
return el.poller.Trigger(queue.LowPriority, el.execCmd, cmd)
}
return el.poller.Trigger(el.execCmd, cmd)
}
*/
================================================
FILE: engine_windows.go
================================================
// Copyright (c) 2023 The Gnet Authors. All rights reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
package gnet
import (
"context"
"errors"
"strings"
"sync/atomic"
"golang.org/x/sync/errgroup"
errorx "github.com/panjf2000/gnet/v2/pkg/errors"
"github.com/panjf2000/gnet/v2/pkg/logging"
)
type engine struct {
listeners []*listener
opts *Options // options with engine
eventLoops loadBalancer // event-loops for handling events
inShutdown atomic.Bool // whether the engine is in shutdown
beingShutdown atomic.Bool // whether the engine is being shutdown
turnOff context.CancelFunc
eventHandler EventHandler // user eventHandler
concurrency struct {
*errgroup.Group
ctx context.Context
}
}
func (eng *engine) isShutdown() bool {
return eng.inShutdown.Load()
}
// shutdown signals the engine to shut down.
func (eng *engine) shutdown(err error) {
if err != nil && !errors.Is(err, errorx.ErrEngineShutdown) {
eng.opts.Logger.Errorf("engine is being shutdown with error: %v", err)
}
eng.turnOff()
eng.beingShutdown.Store(true)
}
func (eng *engine) closeEventLoops() {
eng.eventLoops.iterate(func(i int, el *eventloop) bool {
el.ch <- errorx.ErrEngineShutdown
return true
})
for _, ln := range eng.listeners {
ln.close()
}
}
func (eng *engine) start(ctx context.Context, numEventLoop int) error {
var el0 *eventloop
for i := 0; i < numEventLoop; i++ {
el := eventloop{
ch: make(chan any, 1024),
eng: eng,
connections: make(map[*conn]struct{}),
eventHandler: eng.eventHandler,
}
eng.eventLoops.register(&el)
eng.concurrency.Go(el.run)
if i == 0 && eng.opts.Ticker {
el0 = &el
}
}
if el0 != nil {
eng.concurrency.Go(func() error {
el0.ticker(ctx)
return nil
})
}
for _, ln := range eng.listeners {
l := ln
if l.pc != nil {
eng.concurrency.Go(func() error {
return eng.ListenUDP(l.pc)
})
} else {
eng.concurrency.Go(func() error {
return eng.listenStream(l.ln)
})
}
}
return nil
}
func (eng *engine) stop(ctx context.Context, engine Engine) {
<-ctx.Done()
eng.eventHandler.OnShutdown(engine)
eng.closeEventLoops()
if err := eng.concurrency.Wait(); err != nil && !errors.Is(err, errorx.ErrEngineShutdown) {
eng.opts.Logger.Errorf("engine shutdown error: %v", err)
}
eng.inShutdown.Store(true)
}
func run(eventHandler EventHandler, listeners []*listener, options *Options, addrs []string) error {
numEventLoop := determineEventLoops(options)
logging.Infof("Launching gnet with %d event-loops, listening on: %s",
numEventLoop, strings.Join(addrs, " | "))
rootCtx, shutdown := context.WithCancel(context.Background())
eg, ctx := errgroup.WithContext(rootCtx)
eng := engine{
opts: options,
listeners: listeners,
turnOff: shutdown,
eventHandler: eventHandler,
concurrency: struct {
*errgroup.Group
ctx context.Context
}{eg, ctx},
}
switch options.LB {
case RoundRobin:
eng.eventLoops = new(roundRobinLoadBalancer)
// If there are more than one listener, we can't use roundRobinLoadBalancer because
// it's not concurrency-safe, replace it with leastConnectionsLoadBalancer.
if len(listeners) > 1 {
eng.eventLoops = new(leastConnectionsLoadBalancer)
}
case LeastConnections:
eng.eventLoops = new(leastConnectionsLoadBalancer)
case SourceAddrHash:
eng.eventLoops = new(sourceAddrHashLoadBalancer)
}
engine := Engine{eng: &eng}
switch eventHandler.OnBoot(engine) {
case None, Close:
case Shutdown:
return nil
}
if err := eng.start(ctx, numEventLoop); err != nil {
eng.opts.Logger.Errorf("gnet engine is stopping with error: %v", err)
return err
}
defer eng.stop(rootCtx, engine)
for _, addr := range addrs {
allEngines.Store(addr, &eng)
}
return nil
}
/*
func (eng *engine) sendCmd(_ *asyncCmd, _ bool) error {
return errorx.ErrUnsupportedOp
}
*/
================================================
FILE: eventloop_unix.go
================================================
// Copyright (c) 2019 The Gnet Authors. All rights reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//go:build darwin || dragonfly || freebsd || linux || netbsd || openbsd
package gnet
import (
"context"
"errors"
"fmt"
"io"
"net"
"os"
"strconv"
"strings"
"syscall"
"time"
"golang.org/x/sys/unix"
errorx "github.com/panjf2000/gnet/v2/pkg/errors"
gio "github.com/panjf2000/gnet/v2/pkg/io"
"github.com/panjf2000/gnet/v2/pkg/logging"
"github.com/panjf2000/gnet/v2/pkg/netpoll"
"github.com/panjf2000/gnet/v2/pkg/pool/goroutine"
"github.com/panjf2000/gnet/v2/pkg/queue"
"github.com/panjf2000/gnet/v2/pkg/socket"
)
type eventloop struct {
listeners map[int]*listener // listeners
idx int // loop index in the engine loops list
engine *engine // engine in loop
poller *netpoll.Poller // epoll or kqueue
buffer []byte // read packet buffer whose capacity is set by user, default value is 64KB
connections connMatrix // loop connections storage
eventHandler EventHandler // user eventHandler
}
func (el *eventloop) Register(ctx context.Context, addr net.Addr) (<-chan RegisteredResult, error) {
if el.engine.isShutdown() {
return nil, errorx.ErrEngineInShutdown
}
if addr == nil {
return nil, errorx.ErrInvalidNetworkAddress
}
return el.enroll(nil, addr, FromContext(ctx))
}
func (el *eventloop) Enroll(ctx context.Context, c net.Conn) (<-chan RegisteredResult, error) {
if el.engine.isShutdown() {
return nil, errorx.ErrEngineInShutdown
}
if c == nil {
return nil, errorx.ErrInvalidNetConn
}
return el.enroll(c, c.RemoteAddr(), FromContext(ctx))
}
func (el *eventloop) Execute(ctx context.Context, runnable Runnable) error {
if el.engine.isShutdown() {
return errorx.ErrEngineInShutdown
}
if runnable == nil {
return errorx.ErrNilRunnable
}
return el.poller.Trigger(queue.LowPriority, func(any) error {
return runnable.Run(ctx)
}, nil)
}
func (el *eventloop) Schedule(context.Context, Runnable, time.Duration) error {
return errorx.ErrUnsupportedOp
}
func (el *eventloop) Close(c Conn) error {
return el.close(c.(*conn), nil)
}
func (el *eventloop) getLogger() logging.Logger {
return el.engine.opts.Logger
}
func (el *eventloop) countConn() int32 {
return el.connections.loadCount()
}
func (el *eventloop) closeConns() {
// Close loops and all outstanding connections
el.connections.iterate(func(c *conn) bool {
_ = el.close(c, nil)
return true
})
}
type connWithCallback struct {
c *conn
cb func()
}
func (el *eventloop) enroll(c net.Conn, addr net.Addr, ctx any) (resCh chan RegisteredResult, err error) {
resCh = make(chan RegisteredResult, 1)
err = goroutine.DefaultWorkerPool.Submit(func() {
defer close(resCh)
var err error
if c == nil {
if c, err = net.Dial(addr.Network(), addr.String()); err != nil {
resCh <- RegisteredResult{Err: err}
return
}
}
defer c.Close() //nolint:errcheck
sc, ok := c.(syscall.Conn)
if !ok {
resCh <- RegisteredResult{
Err: fmt.Errorf("failed to assert syscall.Conn from net.Conn: %s", addr.String()),
}
return
}
rc, err := sc.SyscallConn()
if err != nil {
resCh <- RegisteredResult{Err: err}
return
}
var dupFD int
err1 := rc.Control(func(fd uintptr) {
dupFD, err = socket.Dup(int(fd))
})
if err != nil {
resCh <- RegisteredResult{Err: err}
return
}
if err1 != nil {
resCh <- RegisteredResult{Err: err1}
return
}
var (
sockAddr unix.Sockaddr
gc *conn
)
switch c.(type) {
case *net.UnixConn:
sockAddr, _, _, err = socket.GetUnixSockAddr(c.RemoteAddr().Network(), c.RemoteAddr().String())
if err != nil {
resCh <- RegisteredResult{Err: err}
return
}
ua := c.LocalAddr().(*net.UnixAddr)
ua.Name = c.RemoteAddr().String() + "." + strconv.Itoa(dupFD)
gc = newStreamConn("unix", dupFD, el, sockAddr, c.LocalAddr(), c.RemoteAddr())
case *net.TCPConn:
sockAddr, _, _, _, err = socket.GetTCPSockAddr(c.RemoteAddr().Network(), c.RemoteAddr().String())
if err != nil {
resCh <- RegisteredResult{Err: err}
return
}
gc = newStreamConn("tcp", dupFD, el, sockAddr, c.LocalAddr(), c.RemoteAddr())
case *net.UDPConn:
sockAddr, _, _, _, err = socket.GetUDPSockAddr(c.RemoteAddr().Network(), c.RemoteAddr().String())
if err != nil {
resCh <- RegisteredResult{Err: err}
return
}
gc = newUDPConn(dupFD, el, c.LocalAddr(), sockAddr, true)
default:
resCh <- RegisteredResult{Err: fmt.Errorf("unknown type of conn: %T", c)}
return
}
gc.ctx = ctx
connOpened := make(chan struct{})
ccb := &connWithCallback{c: gc, cb: func() {
close(connOpened)
}}
if err := el.poller.Trigger(queue.LowPriority, el.register, ccb); err != nil {
gc.Close() //nolint:errcheck
resCh <- RegisteredResult{Err: err}
return
}
<-connOpened
resCh <- RegisteredResult{Conn: gc}
})
return
}
func (el *eventloop) register(a any) error {
c, ok := a.(*conn)
if !ok {
ccb := a.(*connWithCallback)
c = ccb.c
defer ccb.cb()
}
return el.register0(c)
}
func (el *eventloop) register0(c *conn) error {
addEvents := el.poller.AddRead
if el.engine.opts.EdgeTriggeredIO {
addEvents = el.poller.AddReadWrite
}
if err := addEvents(&c.pollAttachment, el.engine.opts.EdgeTriggeredIO); err != nil {
_ = unix.Close(c.fd)
c.release()
return err
}
el.connections.addConn(c, el.idx)
if c.isDatagram && c.remote != nil {
return nil
}
return el.open(c)
}
func (el *eventloop) open(c *conn) error {
c.opened = true
out, action := el.eventHandler.OnOpen(c)
if out != nil {
if err := c.open(out); err != nil {
return err
}
}
if !c.outboundBuffer.IsEmpty() && !el.engine.opts.EdgeTriggeredIO {
if err := el.poller.ModReadWrite(&c.pollAttachment, false); err != nil {
return err
}
}
return el.handleAction(c, action)
}
func (el *eventloop) read0(a any) error {
return el.read(a.(*conn))
}
func (el *eventloop) read(c *conn) error {
if !c.opened {
return nil
}
var recv int
isET := el.engine.opts.EdgeTriggeredIO
chunk := el.engine.opts.EdgeTriggeredIOChunk
loop:
n, err := unix.Read(c.fd, el.buffer)
if err != nil || n == 0 {
if err == unix.EAGAIN {
return nil
}
if n == 0 {
err = io.EOF
}
return el.close(c, os.NewSyscallError("read", err))
}
recv += n
c.buffer = el.buffer[:n]
action := el.eventHandler.OnTraffic(c)
switch action {
case None:
case Close:
return el.close(c, nil)
case Shutdown:
return errorx.ErrEngineShutdown
}
_, _ = c.inboundBuffer.Write(c.buffer)
c.buffer = c.buffer[:0]
if c.isEOF || (isET && recv < chunk) {
goto loop
}
// To prevent infinite reading in ET mode and starving other events,
// we need to set up threshold for the maximum read bytes per connection
// on each event-loop. If the threshold is reached and there are still
// unread data in the socket buffer, we must issue another read event manually.
if isET && n == len(el.buffer) {
return el.poller.Trigger(queue.LowPriority, el.read0, c)
}
return nil
}
func (el *eventloop) write0(a any) error {
return el.write(a.(*conn))
}
// The default value of UIO_MAXIOV/IOV_MAX is 1024 on Linux and most BSD-like OSs.
const iovMax = 1024
func (el *eventloop) write(c *conn) error {
if c.outboundBuffer.IsEmpty() {
return nil
}
isET := el.engine.opts.EdgeTriggeredIO
chunk := el.engine.opts.EdgeTriggeredIOChunk
var (
n int
sent int
err error
)
loop:
iov, _ := c.outboundBuffer.Peek(-1)
if len(iov) > 1 {
if len(iov) > iovMax {
iov = iov[:iovMax]
}
n, err = gio.Writev(c.fd, iov)
} else {
n, err = unix.Write(c.fd, iov[0])
}
_, _ = c.outboundBuffer.Discard(n)
switch err {
case nil:
case unix.EAGAIN:
return nil
default:
return el.close(c, os.NewSyscallError("write", err))
}
sent += n
if isET && !c.outboundBuffer.IsEmpty() && sent < chunk {
goto loop
}
// All data have been sent, it's no need to monitor the writable events for LT mode,
// remove the writable event from poller to help the future event-loops if necessary.
if !isET && c.outboundBuffer.IsEmpty() {
return el.poller.ModRead(&c.pollAttachment, false)
}
// To prevent infinite writing in ET mode and starving other events,
// we need to set up threshold for the maximum write bytes per connection
// on each event-loop. If the threshold is reached and there are still
// pending data to write, we must issue another write event manually.
if isET && !c.outboundBuffer.IsEmpty() {
return el.poller.Trigger(queue.HighPriority, el.write0, c)
}
return nil
}
func (el *eventloop) close(c *conn, err error) error {
if !c.opened || el.connections.getConn(c.fd) == nil {
return nil // ignore stale connections
}
el.connections.delConn(c)
action := el.eventHandler.OnClose(c, err)
// Send residual data in buffer back to the remote before actually closing the connection.
for !c.outboundBuffer.IsEmpty() {
iov, _ := c.outboundBuffer.Peek(0)
if len(iov) > iovMax {
iov = iov[:iovMax]
}
n, err := gio.Writev(c.fd, iov)
if err != nil {
break
}
_, _ = c.outboundBuffer.Discard(n)
}
c.release()
var errStr strings.Builder
err0, err1 := el.poller.Delete(c.fd), unix.Close(c.fd)
if err0 != nil {
err0 = fmt.Errorf("failed to delete fd=%d from poller in event-loop(%d): %v",
c.fd, el.idx, os.NewSyscallError("delete", err0))
errStr.WriteString(err0.Error())
errStr.WriteString(" | ")
}
if err1 != nil {
err1 = fmt.Errorf("failed to close fd=%d in event-loop(%d): %v",
c.fd, el.idx, os.NewSyscallError("close", err1))
errStr.WriteString(err1.Error())
}
if errStr.Len() > 0 {
return errors.New(strings.TrimSuffix(errStr.String(), " | "))
}
return el.handleAction(c, action)
}
func (el *eventloop) wake(c *conn) error {
if !c.opened || el.connections.getConn(c.fd) == nil {
return nil // ignore stale connections
}
action := el.eventHandler.OnTraffic(c)
return el.handleAction(c, action)
}
func (el *eventloop) ticker(ctx context.Context) {
var (
action Action
delay time.Duration
timer *time.Timer
)
defer func() {
if timer != nil {
timer.Stop()
}
}()
for {
delay, action = el.eventHandler.OnTick()
switch action {
case None, Close:
case Shutdown:
// It seems reasonable to mark this as low-priority, waiting for some tasks like asynchronous writes
// to finish up before shutting down the service.
err := el.poller.Trigger(queue.LowPriority, func(_ any) error { return errorx.ErrEngineShutdown }, nil)
el.getLogger().Debugf("failed to enqueue shutdown signal of high-priority for event-loop(%d): %v", el.idx, err)
}
if timer == nil {
timer = time.NewTimer(delay)
} else {
timer.Reset(delay)
}
select {
case <-ctx.Done():
el.getLogger().Debugf("stopping ticker in event-loop(%d) from Engine, error:%v", el.idx, ctx.Err())
return
case <-timer.C:
}
}
}
func (el *eventloop) readUDP(fd int, _ netpoll.IOEvent, _ netpoll.IOFlags) error {
n, sa, err := unix.Recvfrom(fd, el.buffer, 0)
if err != nil {
if err == unix.EAGAIN {
return nil
}
return fmt.Errorf("failed to read UDP packet from fd=%d in event-loop(%d), %v",
fd, el.idx, os.NewSyscallError("recvfrom", err))
}
var c *conn
if ln, ok := el.listeners[fd]; ok {
c = newUDPConn(fd, el, ln.addr, sa, false)
} else {
c = el.connections.getConn(fd)
}
c.buffer = el.buffer[:n]
action := el.eventHandler.OnTraffic(c)
if c.remote != nil {
c.release()
}
if action == Shutdown {
return errorx.ErrEngineShutdown
}
return nil
}
func (el *eventloop) handleAction(c *conn, action Action) error {
switch action {
case None:
return nil
case Close:
return el.close(c, nil)
case Shutdown:
return errorx.ErrEngineShutdown
default:
return nil
}
}
/*
func (el *eventloop) execCmd(a any) (err error) {
cmd := a.(*asyncCmd)
c := el.connections.getConnByGFD(cmd.fd)
if c == nil || c.gfd != cmd.fd {
return errorx.ErrInvalidConn
}
defer func() {
if cmd.cb != nil {
_ = cmd.cb(c, err)
}
}()
switch cmd.typ {
case asyncCmdClose:
return el.close(c, nil)
case asyncCmdWake:
return el.wake(c)
case asyncCmdWrite:
_, err = c.Write(cmd.param.([]byte))
case asyncCmdWritev:
_, err = c.Writev(cmd.param.([][]byte))
default:
return errorx.ErrUnsupportedOp
}
return
}
*/
================================================
FILE: eventloop_unix_test.go
================================================
//go:build darwin || dragonfly || freebsd || linux || netbsd || openbsd
package gnet
import (
"context"
"net"
"runtime"
"runtime/debug"
"sync/atomic"
"testing"
"time"
"golang.org/x/sys/unix"
"github.com/stretchr/testify/assert"
goPool "github.com/panjf2000/gnet/v2/pkg/pool/goroutine"
)
func (lb *roundRobinLoadBalancer) register(el *eventloop) {
lb.baseLoadBalancer.register(el)
registerInitConn(el)
}
func (lb *leastConnectionsLoadBalancer) register(el *eventloop) {
lb.baseLoadBalancer.register(el)
registerInitConn(el)
}
func (lb *sourceAddrHashLoadBalancer) register(el *eventloop) {
lb.baseLoadBalancer.register(el)
registerInitConn(el)
}
func registerInitConn(el *eventloop) {
for i := 0; i < int(atomic.LoadInt32(&nowEventLoopInitConn)); i++ {
c := newStreamConn("tcp", i, el, &unix.SockaddrInet4{}, &net.TCPAddr{}, &net.TCPAddr{})
el.connections.addConn(c, el.idx)
}
}
// nowEventLoopInitConn initializes the number of conn fake data, must be set to 0 after use.
var (
nowEventLoopInitConn int32
testBigGC = false
)
func BenchmarkGC4El100k(b *testing.B) {
oldGc := debug.SetGCPercent(-1)
ts1 := benchServeGC(b, "tcp", ":0", true, 4, 100000)
b.Run("Run-4-eventloop-100000", func(b *testing.B) {
for i := 0; i < b.N; i++ {
runtime.GC()
}
})
_ = ts1.eng.Stop(context.Background())
debug.SetGCPercent(oldGc)
}
func BenchmarkGC4El200k(b *testing.B) {
oldGc := debug.SetGCPercent(-1)
ts1 := benchServeGC(b, "tcp", ":0", true, 4, 200000)
b.Run("Run-4-eventloop-200000", func(b *testing.B) {
for i := 0; i < b.N; i++ {
runtime.GC()
}
})
_ = ts1.eng.Stop(context.Background())
debug.SetGCPercent(oldGc)
}
func BenchmarkGC4El500k(b *testing.B) {
oldGc := debug.SetGCPercent(-1)
ts1 := benchServeGC(b, "tcp", ":0", true, 4, 500000)
b.Run("Run-4-eventloop-500000", func(b *testing.B) {
for i := 0; i < b.N; i++ {
runtime.GC()
}
})
_ = ts1.eng.Stop(context.Background())
debug.SetGCPercent(oldGc)
}
func benchServeGC(b *testing.B, network, addr string, async bool, elNum int, initConnCount int32) *benchmarkServerGC {
ts := &benchmarkServerGC{
tester: b,
network: network,
addr: addr,
async: async,
elNum: elNum,
initOk: make(chan struct{}),
initConnCount: initConnCount,
}
nowEventLoopInitConn = initConnCount
_ = goPool.DefaultWorkerPool.Submit(func() {
err := Run(ts,
network+"://"+addr,
WithLockOSThread(async),
WithNumEventLoop(elNum),
WithTCPKeepAlive(time.Minute),
WithTCPNoDelay(TCPDelay))
assert.NoError(b, err)
nowEventLoopInitConn = 0
})
<-ts.initOk
return ts
}
type benchmarkServerGC struct {
*BuiltinEventEngine
tester *testing.B
eng Engine
network string
addr string
async bool
elNum int
initConnCount int32
initOk chan struct{}
}
func (s *benchmarkServerGC) OnBoot(eng Engine) (action Action) {
s.eng = eng
_ = goPool.DefaultWorkerPool.Submit(func() {
for s.eng.eng.eventLoops.len() != s.elNum || s.eng.CountConnections() != s.elNum*int(s.initConnCount) {
time.Sleep(time.Millisecond)
}
close(s.initOk)
})
return
}
// TestServeGC generate fake data asynchronously, if you need to test, manually open the comment.
func TestServeGC(t *testing.T) {
t.Run("gc-loop", func(t *testing.T) {
t.Run("1-loop-10000", func(t *testing.T) {
if testBigGC {
t.Skipf("Skip when testBigGC=%t", testBigGC)
}
testServeGC(t, "tcp", ":0", true, true, 1, 10000)
})
t.Run("1-loop-100000", func(t *testing.T) {
if !testBigGC {
t.Skipf("Skip when testBigGC=%t", testBigGC)
}
testServeGC(t, "tcp", ":0", true, true, 1, 100000)
})
t.Run("1-loop-1000000", func(t *testing.T) {
if !testBigGC {
t.Skipf("Skip when testBigGC=%t", testBigGC)
}
testServeGC(t, "tcp", ":0", true, true, 1, 1000000)
})
t.Run("2-loop-10000", func(t *testing.T) {
if testBigGC {
t.Skipf("Skip when testBigGC=%t", testBigGC)
}
testServeGC(t, "tcp", ":0", true, true, 2, 10000)
})
t.Run("2-loop-100000", func(t *testing.T) {
if !testBigGC {
t.Skipf("Skip when testBigGC=%t", testBigGC)
}
testServeGC(t, "tcp", ":0", true, true, 2, 100000)
})
t.Run("2-loop-1000000", func(t *testing.T) {
if !testBigGC {
t.Skipf("Skip when testBigGC=%t", testBigGC)
}
testServeGC(t, "tcp", ":0", true, true, 2, 1000000)
})
t.Run("4-loop-10000", func(t *testing.T) {
if testBigGC {
t.Skipf("Skip when testBigGC=%t", testBigGC)
}
testServeGC(t, "tcp", ":0", true, true, 4, 10000)
})
t.Run("4-loop-100000", func(t *testing.T) {
if !testBigGC {
t.Skipf("Skip when testBigGC=%t", testBigGC)
}
testServeGC(t, "tcp", ":0", true, true, 4, 100000)
})
t.Run("4-loop-1000000", func(t *testing.T) {
if !testBigGC {
t.Skipf("Skip when testBigGC=%t", testBigGC)
}
testServeGC(t, "tcp", ":0", true, true, 4, 1000000)
})
t.Run("16-loop-10000", func(t *testing.T) {
if testBigGC {
t.Skipf("Skip when testBigGC=%t", testBigGC)
}
testServeGC(t, "tcp", ":0", true, true, 16, 10000)
})
t.Run("16-loop-100000", func(t *testing.T) {
if !testBigGC {
t.Skipf("Skip when testBigGC=%t", testBigGC)
}
testServeGC(t, "tcp", ":0", true, true, 16, 100000)
})
t.Run("16-loop-1000000", func(t *testing.T) {
if !testBigGC {
t.Skipf("Skip when testBigGC=%t", testBigGC)
}
testServeGC(t, "tcp", ":0", true, true, 16, 1000000)
})
})
}
func testServeGC(t *testing.T, network, addr string, multicore, async bool, elNum int, initConnCount int32) {
ts := &testServerGC{
tester: t,
network: network,
addr: addr,
multicore: multicore,
async: async,
elNum: elNum,
}
nowEventLoopInitConn = initConnCount
err := Run(ts,
network+"://"+addr,
WithLockOSThread(async),
WithMulticore(multicore),
WithNumEventLoop(elNum),
WithTCPKeepAlive(time.Minute),
WithTCPNoDelay(TCPDelay))
assert.NoError(t, err)
nowEventLoopInitConn = 0
}
type testServerGC struct {
*BuiltinEventEngine
tester *testing.T
eng Engine
network string
addr string
multicore bool
async bool
elNum int
}
func (s *testServerGC) OnBoot(eng Engine) (action Action) {
s.eng = eng
gcSecs := 5
if testBigGC {
gcSecs = 10
}
err := goPool.DefaultWorkerPool.Submit(func() {
s.GC(gcSecs)
})
assert.NoError(s.tester, err)
return
}
func (s *testServerGC) GC(secs int) {
defer func() {
_ = s.eng.Stop(context.Background())
runtime.GC()
}()
var gcAllTime, gcAllCount time.Duration
gcStart := time.Now()
for range time.Tick(time.Second) {
gcAllCount++
now := time.Now()
runtime.GC()
gcTime := time.Since(now)
gcAllTime += gcTime
s.tester.Log(s.tester.Name(), s.network, "server gc:", gcTime, "average gc time:", gcAllTime/gcAllCount)
if time.Since(gcStart) >= time.Second*time.Duration(secs) {
break
}
}
}
================================================
FILE: eventloop_windows.go
================================================
// Copyright (c) 2023 The Gnet Authors. All rights reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
package gnet
import (
"context"
"errors"
"fmt"
"net"
"runtime"
"sync/atomic"
"time"
errorx "github.com/panjf2000/gnet/v2/pkg/errors"
"github.com/panjf2000/gnet/v2/pkg/logging"
"github.com/panjf2000/gnet/v2/pkg/pool/goroutine"
)
type eventloop struct {
ch chan any // channel for event-loop
idx int // index of event-loop in event-loops
eng *engine // engine in loop
connCount int32 // number of active connections in event-loop
connections map[*conn]struct{} // TCP connection map: fd -> conn
eventHandler EventHandler // user eventHandler
}
func (el *eventloop) Register(ctx context.Context, addr net.Addr) (<-chan RegisteredResult, error) {
if el.eng.isShutdown() {
return nil, errorx.ErrEngineInShutdown
}
if addr == nil {
return nil, errorx.ErrInvalidNetworkAddress
}
return el.enroll(nil, addr, FromContext(ctx))
}
func (el *eventloop) Enroll(ctx context.Context, c net.Conn) (<-chan RegisteredResult, error) {
if el.eng.isShutdown() {
return nil, errorx.ErrEngineInShutdown
}
if c == nil {
return nil, errorx.ErrInvalidNetConn
}
return el.enroll(c, c.RemoteAddr(), FromContext(ctx))
}
func (el *eventloop) Execute(ctx context.Context, runnable Runnable) error {
if el.eng.isShutdown() {
return errorx.ErrEngineInShutdown
}
if runnable == nil {
return errorx.ErrNilRunnable
}
return goroutine.DefaultWorkerPool.Submit(func() {
el.ch <- func() error {
return runnable.Run(ctx)
}
})
}
func (el *eventloop) Schedule(context.Context, Runnable, time.Duration) error {
return errorx.ErrUnsupportedOp
}
func (el *eventloop) Close(c Conn) error {
return el.close(c.(*conn), nil)
}
func (el *eventloop) getLogger() logging.Logger {
return el.eng.opts.Logger
}
func (el *eventloop) enroll(c net.Conn, addr net.Addr, ctx any) (resCh chan RegisteredResult, err error) {
resCh = make(chan RegisteredResult, 1)
err = goroutine.DefaultWorkerPool.Submit(func() {
defer close(resCh)
var err error
if c == nil {
if c, err = net.Dial(addr.Network(), addr.String()); err != nil {
resCh <- RegisteredResult{Err: err}
return
}
}
connOpened := make(chan struct{})
var gc *conn
switch addr.Network() {
case "tcp", "tcp4", "tcp6", "unix":
gc = newStreamConn(el, c, ctx)
el.ch <- &openConn{c: gc, cb: func() { close(connOpened) }}
goroutine.DefaultWorkerPool.Submit(func() {
var buffer [0x10000]byte
for {
n, err := c.Read(buffer[:])
if err != nil {
el.ch <- &netErr{gc, err}
return
}
el.ch <- packTCPConn(gc, buffer[:n])
}
})
case "udp", "udp4", "udp6":
gc = newUDPConn(el, nil, c, c.LocalAddr(), c.RemoteAddr(), ctx)
el.ch <- &openConn{c: gc, cb: func() { close(connOpened) }}
goroutine.DefaultWorkerPool.Submit(func() {
var buffer [0x10000]byte
for {
n, err := c.Read(buffer[:])
if err != nil {
el.ch <- &netErr{gc, err}
return
}
gc := newUDPConn(el, nil, c, c.LocalAddr(), c.RemoteAddr(), ctx)
el.ch <- packUDPConn(gc, buffer[:n])
}
})
}
<-connOpened
resCh <- RegisteredResult{Conn: gc}
})
return
}
func (el *eventloop) incConn(delta int32) {
atomic.AddInt32(&el.connCount, delta)
}
func (el *eventloop) countConn() int32 {
return atomic.LoadInt32(&el.connCount)
}
func (el *eventloop) run() (err error) {
defer func() {
el.eng.shutdown(err)
for c := range el.connections {
_ = el.close(c, nil)
}
}()
if el.eng.opts.LockOSThread {
runtime.LockOSThread()
defer runtime.UnlockOSThread()
}
for i := range el.ch {
switch v := i.(type) {
case error:
err = v
case *netErr:
err = el.close(v.c, v.err)
case *openConn:
err = el.open(v)
case *tcpConn:
err = el.read(unpackTCPConn(v))
case *udpConn:
err = el.readUDP(v.c)
case func() error:
err = v()
}
if errors.Is(err, errorx.ErrEngineShutdown) {
el.getLogger().Debugf("event-loop(%d) is exiting in terms of the demand from user, %v", el.idx, err)
break
} else if err != nil {
el.getLogger().Debugf("event-loop(%d) got a nonlethal error: %v", el.idx, err)
}
}
return nil
}
func (el *eventloop) open(oc *openConn) error {
if oc.cb != nil {
defer oc.cb()
}
c := oc.c
el.connections[c] = struct{}{}
el.incConn(1)
out, action := el.eventHandler.OnOpen(c)
if out != nil {
if _, err := c.rawConn.Write(out); err != nil {
return err
}
}
return el.handleAction(c, action)
}
func (el *eventloop) read(c *conn) error {
if _, ok := el.connections[c]; !ok {
return nil // ignore stale wakes.
}
action := el.eventHandler.OnTraffic(c)
switch action {
case None:
case Close:
return el.close(c, nil)
case Shutdown:
return errorx.ErrEngineShutdown
}
_, _ = c.inboundBuffer.Write(c.buffer.B)
c.buffer.Reset()
return nil
}
func (el *eventloop) readUDP(c *conn) error {
action := el.eventHandler.OnTraffic(c)
if action == Shutdown {
return errorx.ErrEngineShutdown
}
c.release()
return nil
}
func (el *eventloop) ticker(ctx context.Context) {
if el == nil {
return
}
var (
action Action
delay time.Duration
timer *time.Timer
)
defer func() {
if timer != nil {
timer.Stop()
}
}()
var shutdown bool
for {
delay, action = el.eventHandler.OnTick()
switch action {
case None, Close:
case Shutdown:
if !shutdown {
shutdown = true
el.ch <- errorx.ErrEngineShutdown
el.getLogger().Debugf("stopping ticker in event-loop(%d) from Tick()", el.idx)
}
}
if timer == nil {
timer = time.NewTimer(delay)
} else {
timer.Reset(delay)
}
select {
case <-ctx.Done():
el.getLogger().Debugf("stopping ticker in event-loop(%d) from Server, error:%v", el.idx, ctx.Err())
return
case <-timer.C:
}
}
}
func (el *eventloop) wake(c *conn) error {
if _, ok := el.connections[c]; !ok {
return nil // ignore stale wakes.
}
action := el.eventHandler.OnTraffic(c)
return el.handleAction(c, action)
}
func (el *eventloop) close(c *conn, err error) error {
if _, ok := el.connections[c]; c.rawConn == nil || !ok {
return nil // ignore stale wakes.
}
delete(el.connections, c)
el.incConn(-1)
action := el.eventHandler.OnClose(c, err)
err = c.rawConn.Close()
c.release()
if err != nil {
return fmt.Errorf("failed to close connection=%s in event-loop(%d): %v", c.remoteAddr, el.idx, err)
}
return el.handleAction(c, action)
}
func (el *eventloop) handleAction(c *conn, action Action) error {
switch action {
case None:
return nil
case Close:
return el.close(c, nil)
case Shutdown:
return errorx.ErrEngineShutdown
default:
return nil
}
}
================================================
FILE: gnet.go
================================================
// Copyright (c) 2019 The Gnet Authors. All rights reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
// Package gnet implements a high-performance, lightweight, non-blocking,
// event-driven networking framework written in pure Go.
//
// Visit https://gnet.host/ for more details about gnet.
package gnet
import (
"context"
"io"
"net"
"net/url"
"path"
"runtime"
"strings"
"sync"
"time"
"github.com/panjf2000/gnet/v2/internal/gfd"
"github.com/panjf2000/gnet/v2/pkg/buffer/ring"
errorx "github.com/panjf2000/gnet/v2/pkg/errors"
"github.com/panjf2000/gnet/v2/pkg/logging"
"github.com/panjf2000/gnet/v2/pkg/math"
)
// Action is an action that occurs after the completion of an event.
type Action int
const (
// None indicates that no action should occur following an event.
None Action = iota
// Close closes the connection.
Close
// Shutdown shutdowns the engine.
Shutdown
)
// Engine represents an engine context which provides some functions.
type Engine struct {
// eng is the internal engine struct.
eng *engine
}
// Validate checks whether the engine is available.
func (e Engine) Validate() error {
if e.eng == nil || len(e.eng.listeners) == 0 {
return errorx.ErrEmptyEngine
}
if e.eng.isShutdown() {
return errorx.ErrEngineInShutdown
}
return nil
}
// CountConnections counts the number of currently active connections and returns it.
func (e Engine) CountConnections() (count int) {
if e.Validate() != nil {
return -1
}
e.eng.eventLoops.iterate(func(_ int, el *eventloop) bool {
count += int(el.countConn())
return true
})
return
}
// Register registers the new connection to the event-loop that is chosen
// based off of the algorithm set by WithLoadBalancing.
// You should call either of the NewNetConnContext or NewNetAddrContext
// and pass the returned context to this method. net.Conn will precede
// net.Addr if both are present in the context.
//
// Note that you need to switch to another load-balancing algorithm over
// the default RoundRobin when starting the engine, to avoid data race
// issue if you plan on calling this method from somewhere later on.
func (e Engine) Register(ctx context.Context) (<-chan RegisteredResult, error) {
if err := e.Validate(); err != nil {
return nil, err
}
if e.eng.eventLoops.len() == 0 {
return nil, errorx.ErrEmptyEngine
}
c, ok := FromNetConnContext(ctx)
if ok {
return e.eng.eventLoops.next(c.RemoteAddr()).Enroll(ctx, c)
}
addr, ok := FromNetAddrContext(ctx)
if ok {
return e.eng.eventLoops.next(addr).Register(ctx, addr)
}
return nil, errorx.ErrInvalidNetworkAddress
}
// Dup returns a copy of the underlying file descriptor of listener.
// It is the caller's responsibility to close dupFD when finished.
// Closing listener does not affect dupFD, and closing dupFD does not affect listener.
//
// Note that this method is only available when the engine has only one listener.
func (e Engine) Dup() (fd int, err error) {
if err := e.Validate(); err != nil {
return -1, err
}
if len(e.eng.listeners) > 1 {
return -1, errorx.ErrUnsupportedOp
}
for _, ln := range e.eng.listeners {
fd, err = ln.dup()
}
return
}
// DupListener is like Dup, but it duplicates the listener with the given network and address.
// This is useful when there are multiple listeners.
func (e Engine) DupListener(network, addr string) (int, error) {
if err := e.Validate(); err != nil {
return -1, err
}
for _, ln := range e.eng.listeners {
if ln.network == network && ln.address == addr {
return ln.dup()
}
}
return -1, errorx.ErrInvalidNetworkAddress
}
// Stop gracefully shuts down this Engine without interrupting any active event-loops,
// it waits indefinitely for connections and event-loops to be closed and then shuts down.
func (e Engine) Stop(ctx context.Context) error {
if err := e.Validate(); err != nil {
return err
}
e.eng.shutdown(nil)
ticker := time.NewTicker(shutdownPollInterval)
defer ticker.Stop()
for {
if e.eng.isShutdown() {
return nil
}
select {
case <-ctx.Done():
return ctx.Err()
case <-ticker.C:
}
}
}
/*
type asyncCmdType uint8
const (
asyncCmdClose = iota + 1
asyncCmdWake
asyncCmdWrite
asyncCmdWritev
)
type asyncCmd struct {
fd gfd.GFD
typ asyncCmdType
cb AsyncCallback
param any
}
// AsyncWrite writes data to the given connection asynchronously.
func (e Engine) AsyncWrite(fd gfd.GFD, p []byte, cb AsyncCallback) error {
if err := e.Validate(); err != nil {
return err
}
return e.eng.sendCmd(&asyncCmd{fd: fd, typ: asyncCmdWrite, cb: cb, param: p}, false)
}
// AsyncWritev is like AsyncWrite, but it accepts a slice of byte slices.
func (e Engine) AsyncWritev(fd gfd.GFD, batch [][]byte, cb AsyncCallback) error {
if err := e.Validate(); err != nil {
return err
}
return e.eng.sendCmd(&asyncCmd{fd: fd, typ: asyncCmdWritev, cb: cb, param: batch}, false)
}
// Close closes the given connection.
func (e Engine) Close(fd gfd.GFD, cb AsyncCallback) error {
if err := e.Validate(); err != nil {
return err
}
return e.eng.sendCmd(&asyncCmd{fd: fd, typ: asyncCmdClose, cb: cb}, false)
}
// Wake wakes up the given connection.
func (e Engine) Wake(fd gfd.GFD, cb AsyncCallback) error {
if err := e.Validate(); err != nil {
return err
}
return e.eng.sendCmd(&asyncCmd{fd: fd, typ: asyncCmdWake, cb: cb}, true)
}
*/
// Reader is an interface that consists of a number of methods for reading that Conn must implement.
//
// Note that the methods in this interface are not concurrency-safe for concurrent use,
// you must invoke them within any method in EventHandler.
type Reader interface {
io.Reader
io.WriterTo
// Next returns the next n bytes and advances the inbound buffer.
// buf must not be used in a new goroutine. Otherwise, use Read instead.
//
// If the number of the available bytes is less than requested,
// a pair of (0, io.ErrShortBuffer) is returned.
Next(n int) (buf []byte, err error)
// Peek returns the next n bytes without advancing the inbound buffer,
// the returned bytes remain valid until a Discard is called.
// buf must neither be used in a new goroutine nor anywhere after the call
// to Discard, make a copy of buf manually or use Read otherwise.
//
// If the number of the available bytes is less than requested,
// a pair of (0, io.ErrShortBuffer) is returned.
Peek(n int) (buf []byte, err error)
// Discard advances the inbound buffer with next n bytes, returning the number of bytes discarded.
Discard(n int) (discarded int, err error)
// InboundBuffered returns the number of bytes that can be read from the current buffer.
InboundBuffered() int
}
// Writer is an interface that consists of a number of methods for writing that Conn must implement.
type Writer interface {
io.Writer // not concurrency-safe
io.ReaderFrom // not concurrency-safe
// SendTo transmits a message to the given address, it's not concurrency-safe.
// It is available only for UDP sockets, an ErrUnsupportedOp will be returned
// when it is called on a non-UDP socket.
// This method should be used only when you need to send a message to a specific
// address over the UDP socket, otherwise you should use Conn.Write() instead.
SendTo(buf []byte, addr net.Addr) (n int, err error)
// Writev writes multiple byte slices to remote synchronously, it's not concurrency-safe,
// you must invoke it within any method in EventHandler.
Writev(bs [][]byte) (n int, err error)
// Flush writes any buffered data to the underlying connection, it's not concurrency-safe,
// you must invoke it within any method in EventHandler.
Flush() error
// OutboundBuffered returns the number of bytes that can be read from the current buffer.
// it's not concurrency-safe, you must invoke it within any method in EventHandler.
OutboundBuffered() int
// AsyncWrite writes bytes to remote asynchronously, it's concurrency-safe,
// you don't have to invoke it within any method in EventHandler,
// usually you would call it in an individual goroutine.
//
// Note that it will go synchronously with UDP, so it is needless to call
// this asynchronous method, we may disable this method for UDP and just
// return ErrUnsupportedOp in the future, therefore, please don't rely on
// this method to do something important under UDP, if you're working with UDP,
// just call Conn.Write to send back your data.
AsyncWrite(buf []byte, callback AsyncCallback) (err error)
// AsyncWritev writes multiple byte slices to remote asynchronously,
// you don't have to invoke it within any method in EventHandler,
// usually you would call it in an individual goroutine.
AsyncWritev(bs [][]byte, callback AsyncCallback) (err error)
}
// AsyncCallback is a callback that will be invoked after the asynchronous function finishes.
//
// Note that the parameter gnet.Conn might have been already released when it's UDP protocol,
// thus it shouldn't be accessed.
// This callback will be executed in event-loop, thus it must not block, otherwise,
// it blocks the event-loop.
type AsyncCallback func(c Conn, err error) error
// Socket is a set of functions which manipulate the underlying file descriptor of a connection.
//
// Note that the methods in this interface are concurrency-safe for concurrent use,
// you don't have to invoke them within any method in EventHandler.
type Socket interface {
// Gfd returns the gfd of socket.
// Gfd() gfd.GFD
// Fd returns the underlying file descriptor.
Fd() int
// Dup returns a copy of the underlying file descriptor.
// It is the caller's responsibility to close fd when finished.
// Closing c does not affect fd, and closing fd does not affect c.
//
// The returned file descriptor is different from the
// connection. Attempting to change the properties of the original
// using this duplicate may or may not have the desired effect.
Dup() (int, error)
// SetReadBuffer sets the size of the operating system's
// receive buffer associated with the connection.
SetReadBuffer(size int) error
// SetWriteBuffer sets the size of the operating system's
// transmit buffer associated with the connection.
SetWriteBuffer(size int) error
// SetLinger sets the behavior of Close on a connection which still
// has data waiting to be sent or to be acknowledged.
//
// If secs < 0 (the default), the operating system finishes sending the
// data in the background.
//
// If secs == 0, the operating system discards any unsent or
// unacknowledged data.
//
// If secs > 0, the data is sent in the background as with sec < 0. On
// some operating systems after sec seconds have elapsed any remaining
// unsent data may be discarded.
SetLinger(secs int) error
// SetKeepAlivePeriod tells the operating system to send keep-alive
// messages on the connection and sets period between TCP keep-alive probes.
SetKeepAlivePeriod(d time.Duration) error
// SetKeepAlive enables/disables the TCP keepalive with all socket options:
// TCP_KEEPIDLE, TCP_KEEPINTVL and TCP_KEEPCNT. idle is the value for TCP_KEEPIDLE,
// intvl is the value for TCP_KEEPINTVL, cnt is the value for TCP_KEEPCNT,
// ignored when enabled is false.
//
// With TCP keep-alive enabled, idle is the time (in seconds) the connection
// needs to remain idle before TCP starts sending keep-alive probes,
// intvl is the time (in seconds) between individual keep-alive probes.
// TCP will drop the connection after sending cnt probes without getting
// any replies from the peer; then the socket is destroyed, and OnClose
// is triggered.
//
// If one of idle, intvl, or cnt is less than 1, an error is returned.
SetKeepAlive(enabled bool, idle, intvl time.Duration, cnt int) error
// SetNoDelay controls whether the operating system should delay
// packet transmission in hopes of sending fewer packets (Nagle's
// algorithm).
// The default is true (no delay), meaning that data is sent as soon as possible after a Write.
SetNoDelay(noDelay bool) error
}
// Runnable defines the common protocol of an execution on an event-loop.
// This interface should be implemented and passed to an event-loop in some way,
// then the event-loop will invoke Run to perform the execution.
// !!!Caution: Run must not contain any blocking operations like heavy disk or
// network I/O, or else it will block the event-loop.
type Runnable interface {
// Run is about to be executed by the event-loop.
Run(ctx context.Context) error
}
// RunnableFunc is an adapter to allow the use of ordinary function as a Runnable.
type RunnableFunc func(ctx context.Context) error
// Run executes the RunnableFunc itself.
func (fn RunnableFunc) Run(ctx context.Context) error {
return fn(ctx)
}
// RegisteredResult is the result of a Register call.
type RegisteredResult struct {
Conn Conn
Err error
}
// EventLoop provides a set of methods for manipulating the event-loop.
type EventLoop interface {
// Register connects to the given address and registers the connection to the current event-loop,
// it's concurrency-safe.
Register(ctx context.Context, addr net.Addr) (<-chan RegisteredResult, error)
// Enroll is like Register, but it accepts an established net.Conn instead of a net.Addr,
// it's concurrency-safe.
Enroll(ctx context.Context, c net.Conn) (<-chan RegisteredResult, error)
// Execute will execute the given runnable on the event-loop at some time in the future,
// it's concurrency-safe.
Execute(ctx context.Context, runnable Runnable) error
// Schedule is like Execute, but it allows you to specify when the runnable is executed.
// In other words, the runnable will be executed when the delay duration is reached,
// it's concurrency-safe.
// TODO(panjf2000): not supported yet, implement this.
Schedule(ctx context.Context, runnable Runnable, delay time.Duration) error
// Close closes the given Conn that belongs to the current event-loop.
// It must be called on the same event-loop that the connection belongs to.
// This method is not concurrency-safe, you must invoke it on the event loop.
Close(Conn) error
}
// Conn is an interface of underlying connection.
type Conn interface {
Reader // all methods in Reader are not concurrency-safe.
Writer // some methods in Writer are concurrency-safe, some are not.
Socket // all methods in Socket are concurrency-safe.
// Context returns a user-defined context, it's not concurrency-safe,
// you must invoke it within any method in EventHandler.
Context() (ctx any)
// EventLoop returns the event-loop that the connection belongs to.
// The returned EventLoop is concurrency-safe.
EventLoop() EventLoop
// SetContext sets a user-defined context, it's not concurrency-safe,
// you must invoke it within any method in EventHandler.
SetContext(ctx any)
// LocalAddr is the connection's local socket address, it's not concurrency-safe,
// you must invoke it within any method in EventHandler.
LocalAddr() net.Addr
// RemoteAddr is the connection's remote address, it's not concurrency-safe,
// you must invoke it within any method in EventHandler.
RemoteAddr() net.Addr
// Wake triggers an OnTraffic event for the current connection, it's concurrency-safe.
Wake(callback AsyncCallback) error
// CloseWithCallback closes the current connection, it's concurrency-safe.
// Usually you should provide a non-nil callback for this method,
// otherwise your better choice is Close().
CloseWithCallback(callback AsyncCallback) error
// Close closes the current connection, implements net.Conn, it's concurrency-safe.
Close() error
// SetDeadline implements net.Conn.
SetDeadline(time.Time) error
// SetReadDeadline implements net.Conn.
SetReadDeadline(time.Time) error
// SetWriteDeadline implements net.Conn.
SetWriteDeadline(time.Time) error
}
type (
// EventHandler represents the engine events' callbacks for the Run call.
// Each event has an Action return value that is used manage the state
// of the connection and engine.
EventHandler interface {
// OnBoot fires when the engine is ready for accepting connections.
// The parameter engine has information and various utilities.
OnBoot(eng Engine) (action Action)
// OnShutdown fires when the engine is being shut down, it is called right after
// all event-loops and connections are closed.
OnShutdown(eng Engine)
// OnOpen fires when a new connection has been opened.
//
// The Conn c has information about the connection such as its local and remote addresses.
// The parameter out is the return value which is going to be sent back to the remote.
// Sending large amounts of data back to the remote in OnOpen is usually not recommended.
OnOpen(c Conn) (out []byte, action Action)
// OnClose fires when a connection has been closed.
// The parameter err is the last known connection error.
OnClose(c Conn, err error) (action Action)
// OnTraffic fires when a socket receives data from the remote.
//
// Also check out the comments on Reader and Writer interfaces.
OnTraffic(c Conn) (action Action)
// OnTick fires immediately after the engine starts and will fire again
// following the duration specified by the delay return value.
OnTick() (delay time.Duration, action Action)
}
// BuiltinEventEngine is a built-in implementation of EventHandler which feeds
// each method with an empty implementation, you can embed it within your custom
// struct when you don't intend to implement the entire EventHandler.
BuiltinEventEngine struct{}
)
// OnBoot fires when the engine is ready for accepting connections.
// The parameter engine has information and various utilities.
func (*BuiltinEventEngine) OnBoot(_ Engine) (action Action) {
return
}
// OnShutdown fires when the engine is being shut down, it is called right after
// all event-loops and connections are closed.
func (*BuiltinEventEngine) OnShutdown(_ Engine) {
}
// OnOpen fires when a new connection has been opened.
// The parameter out is the return value which is going to be sent back to the remote.
func (*BuiltinEventEngine) OnOpen(_ Conn) (out []byte, action Action) {
return
}
// OnClose fires when a connection has been closed.
// The parameter err is the last known connection error.
func (*BuiltinEventEngine) OnClose(_ Conn, _ error) (action Action) {
return
}
// OnTraffic fires when a local socket receives data from the remote.
func (*BuiltinEventEngine) OnTraffic(_ Conn) (action Action) {
return
}
// OnTick fires immediately after the engine starts and will fire again
// following the duration specified by the delay return value.
func (*BuiltinEventEngine) OnTick() (delay time.Duration, action Action) {
return
}
// MaxStreamBufferCap is the default buffer size for each stream-oriented connection(TCP/Unix).
var MaxStreamBufferCap = 64 * 1024 // 64KB
func createListeners(addrs []string, opts ...Option) ([]*listener, *Options, error) {
options := loadOptions(opts...)
logger, logFlusher := logging.GetDefaultLogger(), logging.GetDefaultFlusher()
if options.Logger == nil {
if options.LogPath != "" {
logger, logFlusher, _ = logging.CreateLoggerAsLocalFile(options.LogPath, options.LogLevel)
}
options.Logger = logger
} else {
logger = options.Logger
logFlusher = nil
}
logging.SetDefaultLoggerAndFlusher(logger, logFlusher)
logging.Debugf("default logging level is %s", logging.LogLevel())
// The maximum number of operating system threads that the Go program can use is initially set to 10000,
// which should also be the maximum number of I/O event-loops locked to OS threads that users can start up.
if options.LockOSThread && options.NumEventLoop > 10000 {
logging.Errorf("too many event-loops under LockOSThread mode, should be less than 10,000 "+
"while you are trying to set up %d\n", options.NumEventLoop)
return nil, nil, errorx.ErrTooManyEventLoopThreads
}
if options.EdgeTriggeredIOChunk > 0 {
options.EdgeTriggeredIO = true
options.EdgeTriggeredIOChunk = math.CeilToPowerOfTwo(options.EdgeTriggeredIOChunk)
} else if options.EdgeTriggeredIO {
options.EdgeTriggeredIOChunk = 1 << 20 // 1MB
}
rbc := options.ReadBufferCap
switch {
case rbc <= 0:
options.ReadBufferCap = MaxStreamBufferCap
case rbc <= ring.DefaultBufferSize:
options.ReadBufferCap = ring.DefaultBufferSize
default:
options.ReadBufferCap = math.CeilToPowerOfTwo(rbc)
}
wbc := options.WriteBufferCap
switch {
case wbc <= 0:
options.WriteBufferCap = MaxStreamBufferCap
case wbc <= ring.DefaultBufferSize:
options.WriteBufferCap = ring.DefaultBufferSize
default:
options.WriteBufferCap = math.CeilToPowerOfTwo(wbc)
}
var hasUDP, hasUnix bool
for _, addr := range addrs {
proto, _, err := parseProtoAddr(addr)
if err != nil {
return nil, nil, err
}
hasUDP = hasUDP || strings.HasPrefix(proto, "udp")
hasUnix = hasUnix || proto == "unix"
}
// SO_REUSEPORT enables duplicate address and port bindings across various
// Unix-like OSs, whereas there is platform-specific inconsistency:
// Linux implemented SO_REUSEPORT with load balancing for incoming connections
// while *BSD implemented it for only binding to the same address and port, which
// makes it pointless to enable SO_REUSEPORT on *BSD and Darwin for gnet with
// multiple event-loops because only the first or last event-loop will be constantly
// woken up to accept incoming connections and handle I/O events while the rest of
// event-loops remain idle.
// Thus, we disable SO_REUSEPORT on *BSD and Darwin by default.
//
// Note that FreeBSD 12 introduced a new socket option named SO_REUSEPORT_LB
// with the capability of load balancing, it's the equivalent of Linux's SO_REUSEPORT.
// Also note that DragonFlyBSD 3.6.0 extended SO_REUSEPORT to distribute workload to
// available sockets, which makes it the same as Linux's SO_REUSEPORT.
goos := runtime.GOOS
if options.ReusePort &&
(options.Multicore || options.NumEventLoop > 1) &&
(goos != "linux" && goos != "dragonfly" && goos != "freebsd") {
options.ReusePort = false
}
// Despite the fact that SO_REUSEPORT can be set on a Unix domain socket
// via setsockopt() without reporting an error, SO_REUSEPORT is actually
// not supported for sockets of AF_UNIX. Thus, we avoid setting it on the
// Unix domain sockets.
// As of this commit https://git.kernel.org/pub/scm/linux/kernel/git/netdev/net.git/commit/?id=5b0af621c3f6,
// EOPNOTSUPP will be returned when trying to set SO_REUSEPORT on an AF_UNIX socket on Linux. We therefore
// avoid setting it on Unix domain sockets on all UNIX-like platforms to keep this behavior consistent.
if options.ReusePort && hasUnix {
options.ReusePort = false
}
// If there is UDP address in the list, we have no choice but to enable SO_REUSEPORT anyway,
// also disable edge-triggered I/O for UDP by default.
if hasUDP {
options.ReusePort = true
options.EdgeTriggeredIO = false
}
listeners := make([]*listener, len(addrs))
for i, a := range addrs {
proto, addr, err := parseProtoAddr(a)
if err != nil {
return nil, nil, err
}
ln, err := initListener(proto, addr, options)
if err != nil {
return nil, nil, err
}
listeners[i] = ln
}
return listeners, options, nil
}
// Run starts handling events on the specified address.
//
// Address should use a scheme prefix and be formatted
// like `tcp://192.168.0.10:9851` or `unix://socket`.
// Valid network schemes:
//
// tcp - bind to both IPv4 and IPv6
// tcp4 - IPv4
// tcp6 - IPv6
// udp - bind to both IPv4 and IPv6
// udp4 - IPv4
// udp6 - IPv6
// unix - Unix Domain Socket
//
// The "tcp" network scheme is assumed when one is not specified.
func Run(eventHandler EventHandler, protoAddr string, opts ...Option) error {
listeners, options, err := createListeners([]string{protoAddr}, opts...)
if err != nil {
return err
}
defer func() {
for _, ln := range listeners {
ln.close()
}
logging.Cleanup()
}()
return run(eventHandler, listeners, options, []string{protoAddr})
}
// Rotate is like Run but accepts multiple network addresses.
func Rotate(eventHandler EventHandler, addrs []string, opts ...Option) error {
listeners, options, err := createListeners(addrs, opts...)
if err != nil {
return err
}
defer func() {
for _, ln := range listeners {
ln.close()
}
logging.Cleanup()
}()
return run(eventHandler, listeners, options, addrs)
}
var (
allEngines sync.Map
// shutdownPollInterval is how often we poll to check whether engine has been shut down during gnet.Stop().
shutdownPollInterval = 500 * time.Millisecond
)
// Stop gracefully shuts down the engine without interrupting any active event-loops,
// it waits indefinitely for connections and event-loops to be closed and then shuts down.
//
// Deprecated: The global Stop only shuts down the last registered Engine with the same
// protocol and IP:Port as the previous Engine's, which can lead to leaks of Engine if
// you invoke gnet.Run multiple times using the same protocol and IP:Port under the
// condition that WithReuseAddr(true) and WithReusePort(true) are enabled.
// Use Engine.Stop instead.
func Stop(ctx context.Context, protoAddr string) error {
var eng *engine
if s, ok := allEngines.Load(protoAddr); ok {
eng = s.(*engine)
eng.shutdown(nil)
defer allEngines.Delete(protoAddr)
} else {
return errorx.ErrEngineInShutdown
}
if eng.isShutdown() {
return errorx.ErrEngineInShutdown
}
ticker := time.NewTicker(shutdownPollInterval)
defer ticker.Stop()
for {
if eng.isShutdown() {
return nil
}
select {
case <-ctx.Done():
return ctx.Err()
case <-ticker.C:
}
}
}
func parseProtoAddr(protoAddr string) (string, string, error) {
// Percent-encode "%" in the address to avoid url.Parse error.
// This is for cases like this: udp://[ff02::3%lo0]:9991
protoAddr = strings.ReplaceAll(protoAddr, "%", "%25")
if runtime.GOOS == "windows" {
if strings.HasPrefix(protoAddr, "unix://") {
parts := strings.SplitN(protoAddr, "://", 2)
if parts[1] == "" {
return "", "", errorx.ErrInvalidNetworkAddress
}
return parts[0], parts[1], nil
}
}
u, err := url.Parse(protoAddr)
if err != nil {
return "", "", err
}
switch u.Scheme {
case "":
return "", "", errorx.ErrInvalidNetworkAddress
case "tcp", "tcp4", "tcp6", "udp", "udp4", "udp6":
if u.Host == "" || u.Path != "" {
return "", "", errorx.ErrInvalidNetworkAddress
}
return u.Scheme, u.Host, nil
case "unix":
hostPath := path.Join(u.Host, u.Path)
if hostPath == "" {
return "", "", errorx.ErrInvalidNetworkAddress
}
return u.Scheme, hostPath, nil
default:
return "", "", errorx.ErrUnsupportedProtocol
}
}
func determineEventLoops(opts *Options) int {
numEventLoop := 1
if opts.Multicore {
numEventLoop = runtime.NumCPU()
}
if opts.NumEventLoop > 0 {
numEventLoop = opts.NumEventLoop
}
if numEventLoop > gfd.EventLoopIndexMax {
numEventLoop = gfd.EventLoopIndexMax
}
return numEventLoop
}
================================================
FILE: gnet_test.go
================================================
package gnet
import (
"bufio"
"bytes"
"context"
crand "crypto/rand"
"encoding/binary"
"errors"
"io"
"math"
"math/rand"
"net"
"os"
"path/filepath"
"runtime"
"strings"
"sync"
"sync/atomic"
"testing"
"time"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
"go.uber.org/zap"
"golang.org/x/sync/errgroup"
errorx "github.com/panjf2000/gnet/v2/pkg/errors"
"github.com/panjf2000/gnet/v2/pkg/logging"
bbPool "github.com/panjf2000/gnet/v2/pkg/pool/bytebuffer"
goPool "github.com/panjf2000/gnet/v2/pkg/pool/goroutine"
)
var (
datagramLen = 1024
streamLen = 1024 * 1024
)
type testConf struct {
et bool
etChunk int
reuseport bool
multicore bool
async bool
writev bool
clients int
lb LoadBalancing
}
// testUnixAddr uses os.MkdirTemp to get a name that is unique.
// See https://github.com/golang/go/issues/62614.
func testUnixAddr(t testing.TB) string {
// Pass an empty pattern to get a directory name that is as short as possible.
// If we end up with a name longer than the sun_path field in the sockaddr_un
// struct, we won't be able to make the syscall to open the socket.
d, err := os.MkdirTemp("", "")
require.NoError(t, err)
t.Cleanup(func() { require.NoError(t, os.RemoveAll(d)) })
return filepath.Join(d, "sock")
}
func TestServer(t *testing.T) {
// start an engine
// connect 10 clients
// each client will pipe random data for 1-3 seconds.
// the writes to the engine will be random sizes. 0KB - 1MB.
// the engine will echo back the data.
// waits for graceful connection closing.
t.Run("poll-LT", func(t *testing.T) {
t.Run("tcp", func(t *testing.T) {
t.Run("1-loop", func(t *testing.T) {
runServer(t, []string{"tcp://:9991"}, &testConf{false, 0, false, false, false, false, 10, RoundRobin})
})
t.Run("N-loop", func(t *testing.T) {
runServer(t, []string{"tcp://:9992"}, &testConf{false, 0, false, true, false, false, 10, LeastConnections})
})
})
t.Run("tcp-async", func(t *testing.T) {
t.Run("1-loop", func(t *testing.T) {
runServer(t, []string{"tcp://:9991"}, &testConf{false, 0, false, false, true, false, 10, RoundRobin})
})
t.Run("N-loop", func(t *testing.T) {
runServer(t, []string{"tcp://:9992"}, &testConf{false, 0, false, true, true, false, 10, LeastConnections})
})
})
t.Run("tcp-async-writev", func(t *testing.T) {
t.Run("1-loop", func(t *testing.T) {
runServer(t, []string{"tcp://:9991"}, &testConf{false, 0, false, false, true, true, 10, RoundRobin})
})
t.Run("N-loop", func(t *testing.T) {
runServer(t, []string{"tcp://:9992"}, &testConf{false, 0, false, true, true, true, 10, LeastConnections})
})
})
t.Run("udp", func(t *testing.T) {
t.Run("1-loop", func(t *testing.T) {
runServer(t, []string{"udp://:9991"}, &testConf{false, 0, false, false, false, false, 10, RoundRobin})
})
t.Run("N-loop", func(t *testing.T) {
runServer(t, []string{"udp://:9992"}, &testConf{false, 0, false, true, false, false, 10, LeastConnections})
})
})
t.Run("udp-async", func(t *testing.T) {
t.Run("1-loop", func(t *testing.T) {
runServer(t, []string{"udp://:9991"}, &testConf{false, 0, false, false, true, false, 10, RoundRobin})
})
t.Run("N-loop", func(t *testing.T) {
runServer(t, []string{"udp://:9992"}, &testConf{false, 0, false, true, true, false, 10, LeastConnections})
})
})
t.Run("unix", func(t *testing.T) {
t.Run("1-loop", func(t *testing.T) {
runServer(t, []string{"unix://" + testUnixAddr(t)}, &testConf{false, 0, false, false, false, false, 10, RoundRobin})
})
t.Run("N-loop", func(t *testing.T) {
runServer(t, []string{"unix://" + testUnixAddr(t)}, &testConf{false, 0, false, true, false, false, 10, SourceAddrHash})
})
})
t.Run("unix-async", func(t *testing.T) {
t.Run("1-loop", func(t *testing.T) {
runServer(t, []string{"unix://" + testUnixAddr(t)}, &testConf{false, 0, false, false, true, false, 10, RoundRobin})
})
t.Run("N-loop", func(t *testing.T) {
runServer(t, []string{"unix://" + testUnixAddr(t)}, &testConf{false, 0, false, true, true, false, 10, SourceAddrHash})
})
})
t.Run("unix-async-writev", func(t *testing.T) {
t.Run("1-loop", func(t *testing.T) {
runServer(t, []string{"unix://" + testUnixAddr(t)}, &testConf{false, 0, false, false, true, true, 10, RoundRobin})
})
t.Run("N-loop", func(t *testing.T) {
runServer(t, []string{"unix://" + testUnixAddr(t)}, &testConf{false, 0, false, true, true, true, 10, SourceAddrHash})
})
})
})
t.Run("poll-ET", func(t *testing.T) {
t.Run("tcp", func(t *testing.T) {
t.Run("1-loop", func(t *testing.T) {
runServer(t, []string{"tcp://:9991"}, &testConf{true, 0, false, false, false, false, 10, RoundRobin})
})
t.Run("N-loop", func(t *testing.T) {
runServer(t, []string{"tcp://:9992"}, &testConf{true, 0, false, true, false, false, 10, LeastConnections})
})
})
t.Run("tcp-async", func(t *testing.T) {
t.Run("1-loop", func(t *testing.T) {
runServer(t, []string{"tcp://:9991"}, &testConf{true, 0, false, false, true, false, 10, RoundRobin})
})
t.Run("N-loop", func(t *testing.T) {
runServer(t, []string{"tcp://:9992"}, &testConf{true, 0, false, true, true, false, 10, LeastConnections})
})
})
t.Run("tcp-async-writev", func(t *testing.T) {
t.Run("1-loop", func(t *testing.T) {
runServer(t, []string{"tcp://:9991"}, &testConf{true, 0, false, false, true, true, 10, RoundRobin})
})
t.Run("N-loop", func(t *testing.T) {
runServer(t, []string{"tcp://:9992"}, &testConf{true, 0, false, true, true, true, 10, LeastConnections})
})
})
t.Run("udp", func(t *testing.T) {
t.Run("1-loop", func(t *testing.T) {
runServer(t, []string{"udp://:9991"}, &testConf{true, 0, false, false, false, false, 10, RoundRobin})
})
t.Run("N-loop", func(t *testing.T) {
runServer(t, []string{"udp://:9992"}, &testConf{true, 0, false, true, false, false, 10, LeastConnections})
})
})
t.Run("udp-async", func(t *testing.T) {
t.Run("1-loop", func(t *testing.T) {
runServer(t, []string{"udp://:9991"}, &testConf{true, 0, false, false, true, false, 10, RoundRobin})
})
t.Run("N-loop", func(t *testing.T) {
runServer(t, []string{"udp://:9992"}, &testConf{true, 0, false, true, true, false, 10, LeastConnections})
})
})
t.Run("unix", func(t *testing.T) {
t.Run("1-loop", func(t *testing.T) {
runServer(t, []string{"unix://" + testUnixAddr(t)}, &testConf{true, 0, false, false, false, false, 10, RoundRobin})
})
t.Run("N-loop", func(t *testing.T) {
runServer(t, []string{"unix://" + testUnixAddr(t)}, &testConf{true, 0, false, true, false, false, 10, SourceAddrHash})
})
})
t.Run("unix-async", func(t *testing.T) {
t.Run("1-loop", func(t *testing.T) {
runServer(t, []string{"unix://" + testUnixAddr(t)}, &testConf{true, 0, false, false, true, false, 10, RoundRobin})
})
t.Run("N-loop", func(t *testing.T) {
runServer(t, []string{"unix://" + testUnixAddr(t)}, &testConf{true, 0, false, true, true, false, 10, SourceAddrHash})
})
})
t.Run("unix-async-writev", func(t *testing.T) {
t.Run("1-loop", func(t *testing.T) {
runServer(t, []string{"unix://" + testUnixAddr(t)}, &testConf{true, 0, false, false, true, true, 10, RoundRobin})
})
t.Run("N-loop", func(t *testing.T) {
runServer(t, []string{"unix://" + testUnixAddr(t)}, &testConf{true, 0, false, true, true, true, 10, SourceAddrHash})
})
})
})
t.Run("poll-ET-chunk", func(t *testing.T) {
t.Run("tcp", func(t *testing.T) {
t.Run("1-loop", func(t *testing.T) {
runServer(t, []string{"tcp://:9991"}, &testConf{true, 1 << 18, false, false, false, false, 10, RoundRobin})
})
t.Run("N-loop", func(t *testing.T) {
runServer(t, []string{"tcp://:9992"}, &testConf{true, 1 << 19, false, true, false, false, 10, LeastConnections})
})
})
t.Run("tcp-async", func(t *testing.T) {
t.Run("1-loop", func(t *testing.T) {
runServer(t, []string{"tcp://:9991"}, &testConf{true, 1 << 18, false, false, true, false, 10, RoundRobin})
})
t.Run("N-loop", func(t *testing.T) {
runServer(t, []string{"tcp://:9992"}, &testConf{true, 1 << 19, false, true, true, false, 10, LeastConnections})
})
})
t.Run("tcp-async-writev", func(t *testing.T) {
t.Run("1-loop", func(t *testing.T) {
runServer(t, []string{"tcp://:9991"}, &testConf{true, 1 << 18, false, false, true, true, 10, RoundRobin})
})
t.Run("N-loop", func(t *testing.T) {
runServer(t, []string{"tcp://:9992"}, &testConf{true, 1 << 19, false, true, true, true, 10, LeastConnections})
})
})
t.Run("udp", func(t *testing.T) {
t.Run("1-loop", func(t *testing.T) {
runServer(t, []string{"udp://:9991"}, &testConf{true, 1 << 18, false, false, false, false, 10, RoundRobin})
})
t.Run("N-loop", func(t *testing.T) {
runServer(t, []string{"udp://:9992"}, &testConf{true, 1 << 19, false, true, false, false, 10, LeastConnections})
})
})
t.Run("udp-async", func(t *testing.T) {
t.Run("1-loop", func(t *testing.T) {
runServer(t, []string{"udp://:9991"}, &testConf{true, 1 << 18, false, false, true, false, 10, RoundRobin})
})
t.Run("N-loop", func(t *testing.T) {
runServer(t, []string{"udp://:9992"}, &testConf{true, 1 << 19, false, true, true, false, 10, LeastConnections})
})
})
t.Run("unix", func(t *testing.T) {
t.Run("1-loop", func(t *testing.T) {
runServer(t, []string{"unix://" + testUnixAddr(t)}, &testConf{true, 1 << 18, false, false, false, false, 10, RoundRobin})
})
t.Run("N-loop", func(t *testing.T) {
runServer(t, []string{"unix://" + testUnixAddr(t)}, &testConf{true, 1 << 19, false, true, false, false, 10, SourceAddrHash})
})
})
t.Run("unix-async", func(t *testing.T) {
t.Run("1-loop", func(t *testing.T) {
runServer(t, []string{"unix://" + testUnixAddr(t)}, &testConf{true, 1 << 18, false, false, true, false, 10, RoundRobin})
})
t.Run("N-loop", func(t *testing.T) {
runServer(t, []string{"unix://" + testUnixAddr(t)}, &testConf{true, 1 << 19, false, true, true, false, 10, SourceAddrHash})
})
})
t.Run("unix-async-writev", func(t *testing.T) {
t.Run("1-loop", func(t *testing.T) {
runServer(t, []string{"unix://" + testUnixAddr(t)}, &testConf{true, 1 << 18, false, false, true, true, 10, RoundRobin})
})
t.Run("N-loop", func(t *testing.T) {
runServer(t, []string{"unix://" + testUnixAddr(t)}, &testConf{true, 1 << 19, false, true, true, true, 10, SourceAddrHash})
})
})
})
t.Run("poll-reuseport-LT", func(t *testing.T) {
t.Run("tcp", func(t *testing.T) {
t.Run("1-loop", func(t *testing.T) {
runServer(t, []string{"tcp://:9991"}, &testConf{false, 0, true, false, false, false, 10, RoundRobin})
})
t.Run("N-loop", func(t *testing.T) {
runServer(t, []string{"tcp://:9992"}, &testConf{false, 0, true, true, false, false, 10, LeastConnections})
})
})
t.Run("tcp-async", func(t *testing.T) {
t.Run("1-loop", func(t *testing.T) {
runServer(t, []string{"tcp://:9991"}, &testConf{false, 0, true, false, true, false, 10, RoundRobin})
})
t.Run("N-loop", func(t *testing.T) {
runServer(t, []string{"tcp://:9992"}, &testConf{false, 0, true, true, true, false, 10, LeastConnections})
})
})
t.Run("tcp-async-writev", func(t *testing.T) {
t.Run("1-loop", func(t *testing.T) {
runServer(t, []string{"tcp://:9991"}, &testConf{false, 0, true, false, true, true, 10, RoundRobin})
})
t.Run("N-loop", func(t *testing.T) {
runServer(t, []string{"tcp://:9992"}, &testConf{false, 0, true, true, true, true, 10, LeastConnections})
})
})
t.Run("udp", func(t *testing.T) {
t.Run("1-loop", func(t *testing.T) {
runServer(t, []string{"udp://:9991"}, &testConf{false, 0, true, false, false, false, 10, RoundRobin})
})
t.Run("N-loop", func(t *testing.T) {
runServer(t, []string{"udp://:9992"}, &testConf{false, 0, true, true, false, false, 10, LeastConnections})
})
})
t.Run("udp-async", func(t *testing.T) {
t.Run("1-loop", func(t *testing.T) {
runServer(t, []string{"udp://:9991"}, &testConf{false, 0, true, false, true, false, 10, RoundRobin})
})
t.Run("N-loop", func(t *testing.T) {
runServer(t, []string{"udp://:9992"}, &testConf{false, 0, true, true, true, false, 10, LeastConnections})
})
})
t.Run("unix", func(t *testing.T) {
t.Run("1-loop", func(t *testing.T) {
runServer(t, []string{"unix://" + testUnixAddr(t)}, &testConf{false, 0, true, false, false, false, 10, RoundRobin})
})
t.Run("N-loop", func(t *testing.T) {
runServer(t, []string{"unix://" + testUnixAddr(t)}, &testConf{false, 0, true, true, false, false, 10, LeastConnections})
})
})
t.Run("unix-async", func(t *testing.T) {
t.Run("1-loop", func(t *testing.T) {
runServer(t, []string{"unix://" + testUnixAddr(t)}, &testConf{false, 0, true, false, true, false, 10, RoundRobin})
})
t.Run("N-loop", func(t *testing.T) {
runServer(t, []string{"unix://" + testUnixAddr(t)}, &testConf{false, 0, true, true, true, false, 10, LeastConnections})
})
})
t.Run("unix-async-writev", func(t *testing.T) {
t.Run("1-loop", func(t *testing.T) {
runServer(t, []string{"unix://" + testUnixAddr(t)}, &testConf{false, 0, true, false, true, true, 10, RoundRobin})
})
t.Run("N-loop", func(t *testing.T) {
runServer(t, []string{"unix://" + testUnixAddr(t)}, &testConf{false, 0, true, true, true, true, 10, LeastConnections})
})
})
})
t.Run("poll-reuseport-ET", func(t *testing.T) {
t.Run("tcp", func(t *testing.T) {
t.Run("1-loop", func(t *testing.T) {
runServer(t, []string{"tcp://:9991"}, &testConf{true, 0, true, false, false, false, 10, RoundRobin})
})
t.Run("N-loop", func(t *testing.T) {
runServer(t, []string{"tcp://:9992"}, &testConf{true, 0, true, true, false, false, 10, LeastConnections})
})
})
t.Run("tcp-async", func(t *testing.T) {
t.Run("1-loop", func(t *testing.T) {
runServer(t, []string{"tcp://:9991"}, &testConf{true, 0, true, false, true, false, 10, RoundRobin})
})
t.Run("N-loop", func(t *testing.T) {
runServer(t, []string{"tcp://:9992"}, &testConf{true, 0, true, true, true, false, 10, LeastConnections})
})
})
t.Run("tcp-async-writev", func(t *testing.T) {
t.Run("1-loop", func(t *testing.T) {
runServer(t, []string{"tcp://:9991"}, &testConf{true, 0, true, false, true, true, 10, RoundRobin})
})
t.Run("N-loop", func(t *testing.T) {
runServer(t, []string{"tcp://:9992"}, &testConf{true, 0, true, true, true, true, 10, LeastConnections})
})
})
t.Run("udp", func(t *testing.T) {
t.Run("1-loop", func(t *testing.T) {
runServer(t, []string{"udp://:9991"}, &testConf{true, 0, true, false, false, false, 10, RoundRobin})
})
t.Run("N-loop", func(t *testing.T) {
runServer(t, []string{"udp://:9992"}, &testConf{true, 0, true, true, false, false, 10, LeastConnections})
})
})
t.Run("udp-async", func(t *testing.T) {
t.Run("1-loop", func(t *testing.T) {
runServer(t, []string{"udp://:9991"}, &testConf{true, 0, true, false, true, false, 10, RoundRobin})
})
t.Run("N-loop", func(t *testing.T) {
runServer(t, []string{"udp://:9992"}, &testConf{true, 0, true, true, true, false, 10, LeastConnections})
})
})
t.Run("unix", func(t *testing.T) {
t.Run("1-loop", func(t *testing.T) {
runServer(t, []string{"unix://" + testUnixAddr(t)}, &testConf{true, 0, true, false, false, false, 10, RoundRobin})
})
t.Run("N-loop", func(t *testing.T) {
runServer(t, []string{"unix://" + testUnixAddr(t)}, &testConf{true, 0, true, true, false, false, 10, LeastConnections})
})
})
t.Run("unix-async", func(t *testing.T) {
t.Run("1-loop", func(t *testing.T) {
runServer(t, []string{"unix://" + testUnixAddr(t)}, &testConf{true, 0, true, false, true, false, 10, RoundRobin})
})
t.Run("N-loop", func(t *testing.T) {
runServer(t, []string{"unix://" + testUnixAddr(t)}, &testConf{true, 0, true, true, true, false, 10, LeastConnections})
})
})
t.Run("unix-async-writev", func(t *testing.T) {
t.Run("1-loop", func(t *testing.T) {
runServer(t, []string{"unix://" + testUnixAddr(t)}, &testConf{true, 0, true, false, true, true, 10, RoundRobin})
})
t.Run("N-loop", func(t *testing.T) {
runServer(t, []string{"unix://" + testUnixAddr(t)}, &testConf{true, 0, true, true, true, true, 10, LeastConnections})
})
})
})
t.Run("poll-multi-addrs-LT", func(t *testing.T) {
t.Run("sync", func(t *testing.T) {
t.Run("1-loop", func(t *testing.T) {
runServer(t, []string{"tcp://:9991", "tcp://:9992", "udp://:9993", "udp://:9994", "unix://" + testUnixAddr(t), "unix://" + testUnixAddr(t)}, &testConf{false, 0, false, false, false, false, 10, RoundRobin})
})
t.Run("N-loop", func(t *testing.T) {
runServer(t, []string{"tcp://:9995", "tcp://:9996", "udp://:9997", "udp://:9998", "unix://" + testUnixAddr(t), "unix://" + testUnixAddr(t)}, &testConf{false, 0, false, true, false, false, 10, LeastConnections})
})
})
t.Run("sync-writev", func(t *testing.T) {
t.Run("1-loop", func(t *testing.T) {
runServer(t, []string{"tcp://:9991", "tcp://:9992", "unix://" + testUnixAddr(t), "unix://" + testUnixAddr(t)}, &testConf{false, 0, false, false, false, true, 10, RoundRobin})
})
t.Run("N-loop", func(t *testing.T) {
runServer(t, []string{"tcp://:9995", "tcp://:9996", "unix://" + testUnixAddr(t), "unix://" + testUnixAddr(t)}, &testConf{false, 0, false, true, false, true, 10, LeastConnections})
})
})
t.Run("async", func(t *testing.T) {
t.Run("1-loop", func(t *testing.T) {
runServer(t, []string{"tcp://:9991", "tcp://:9992", "udp://:9993", "udp://:9994", "unix://" + testUnixAddr(t), "unix://" + testUnixAddr(t)}, &testConf{false, 0, false, false, true, false, 10, RoundRobin})
})
t.Run("N-loop", func(t *testing.T) {
runServer(t, []string{"tcp://:9995", "tcp://:9996", "udp://:9997", "udp://:9998", "unix://" + testUnixAddr(t), "unix://" + testUnixAddr(t)}, &testConf{false, 0, false, true, true, false, 10, LeastConnections})
})
})
t.Run("async-writev", func(t *testing.T) {
t.Run("1-loop", func(t *testing.T) {
runServer(t, []string{"tcp://:9991", "tcp://:9992", "unix://" + testUnixAddr(t), "unix://" + testUnixAddr(t)}, &testConf{false, 0, false, false, true, true, 10, RoundRobin})
})
t.Run("N-loop", func(t *testing.T) {
runServer(t, []string{"tcp://:9995", "tcp://:9996", "unix://" + testUnixAddr(t), "unix://" + testUnixAddr(t)}, &testConf{false, 0, false, true, true, true, 10, LeastConnections})
})
})
})
t.Run("poll-multi-addrs-reuseport-LT", func(t *testing.T) {
t.Run("sync", func(t *testing.T) {
t.Run("1-loop", func(t *testing.T) {
runServer(t, []string{"tcp://:9991", "tcp://:9992", "udp://:9993", "udp://:9994", "unix://" + testUnixAddr(t), "unix://" + testUnixAddr(t)}, &testConf{false, 0, true, false, false, false, 10, RoundRobin})
})
t.Run("N-loop", func(t *testing.T) {
runServer(t, []string{"tcp://:9995", "tcp://:9996", "udp://:9997", "udp://:9998", "unix://" + testUnixAddr(t), "unix://" + testUnixAddr(t)}, &testConf{false, 0, true, true, false, false, 10, LeastConnections})
})
})
t.Run("sync-writev", func(t *testing.T) {
t.Run("1-loop", func(t *testing.T) {
runServer(t, []string{"tcp://:9991", "tcp://:9992", "unix://" + testUnixAddr(t), "unix://" + testUnixAddr(t)}, &testConf{false, 0, true, false, false, true, 10, RoundRobin})
})
t.Run("N-loop", func(t *testing.T) {
runServer(t, []string{"tcp://:9995", "tcp://:9996", "unix://" + testUnixAddr(t), "unix://" + testUnixAddr(t)}, &testConf{false, 0, true, true, false, true, 10, LeastConnections})
})
})
t.Run("async", func(t *testing.T) {
t.Run("1-loop", func(t *testing.T) {
runServer(t, []string{"tcp://:9991", "tcp://:9992", "udp://:9993", "udp://:9994", "unix://" + testUnixAddr(t), "unix://" + testUnixAddr(t)}, &testConf{false, 0, true, false, true, false, 10, RoundRobin})
})
t.Run("N-loop", func(t *testing.T) {
runServer(t, []string{"tcp://:9995", "tcp://:9996", "udp://:9997", "udp://:9998", "unix://" + testUnixAddr(t), "unix://" + testUnixAddr(t)}, &testConf{false, 0, true, true, true, false, 10, LeastConnections})
})
})
t.Run("async-writev", func(t *testing.T) {
t.Run("1-loop", func(t *testing.T) {
runServer(t, []string{"tcp://:9991", "tcp://:9992", "unix://" + testUnixAddr(t), "unix://" + testUnixAddr(t)}, &testConf{false, 0, true, false, true, true, 10, RoundRobin})
})
t.Run("N-loop", func(t *testing.T) {
runServer(t, []string{"tcp://:9995", "tcp://:9996", "unix://" + testUnixAddr(t), "unix://" + testUnixAddr(t)}, &testConf{false, 0, true, true, true, true, 10, LeastConnections})
})
})
})
t.Run("poll-multi-addrs-ET", func(t *testing.T) {
t.Run("sync", func(t *testing.T) {
t.Run("1-loop", func(t *testing.T) {
runServer(t, []string{"tcp://:9991", "tcp://:9992", "udp://:9993", "udp://:9994", "unix://" + testUnixAddr(t), "unix://" + testUnixAddr(t)}, &testConf{true, 0, false, false, false, false, 10, RoundRobin})
})
t.Run("N-loop", func(t *testing.T) {
runServer(t, []string{"tcp://:9995", "tcp://:9996", "udp://:9997", "udp://:9998", "unix://" + testUnixAddr(t), "unix://" + testUnixAddr(t)}, &testConf{true, 0, false, true, false, false, 10, LeastConnections})
})
})
t.Run("sync-writev", func(t *testing.T) {
t.Run("1-loop", func(t *testing.T) {
runServer(t, []string{"tcp://:9991", "tcp://:9992", "unix://" + testUnixAddr(t), "unix://" + testUnixAddr(t)}, &testConf{true, 0, false, false, false, true, 10, RoundRobin})
})
t.Run("N-loop", func(t *testing.T) {
runServer(t, []string{"tcp://:9995", "tcp://:9996", "unix://" + testUnixAddr(t), "unix://" + testUnixAddr(t)}, &testConf{true, 0, false, true, false, true, 10, LeastConnections})
})
})
t.Run("async", func(t *testing.T) {
t.Run("1-loop", func(t *testing.T) {
runServer(t, []string{"tcp://:9991", "tcp://:9992", "udp://:9993", "udp://:9994", "unix://" + testUnixAddr(t), "unix://" + testUnixAddr(t)}, &testConf{true, 0, false, false, true, false, 10, RoundRobin})
})
t.Run("N-loop", func(t *testing.T) {
runServer(t, []string{"tcp://:9995", "tcp://:9996", "udp://:9997", "udp://:9998", "unix://" + testUnixAddr(t), "unix://" + testUnixAddr(t)}, &testConf{true, 0, false, true, true, false, 10, LeastConnections})
})
})
t.Run("async-writev", func(t *testing.T) {
t.Run("1-loop", func(t *testing.T) {
runServer(t, []string{"tcp://:9991", "tcp://:9992", "unix://" + testUnixAddr(t), "unix://" + testUnixAddr(t)}, &testConf{true, 0, false, false, true, true, 10, RoundRobin})
})
t.Run("N-loop", func(t *testing.T) {
runServer(t, []string{"tcp://:9995", "tcp://:9996", "unix://" + testUnixAddr(t), "unix://" + testUnixAddr(t)}, &testConf{true, 0, false, true, true, true, 10, LeastConnections})
})
})
})
t.Run("poll-multi-addrs-reuseport-ET", func(t *testing.T) {
t.Run("sync", func(t *testing.T) {
t.Run("1-loop", func(t *testing.T) {
runServer(t, []string{"tcp://:9991", "tcp://:9992", "udp://:9993", "udp://:9994", "unix://" + testUnixAddr(t), "unix://" + testUnixAddr(t)}, &testConf{true, 0, true, false, false, false, 10, RoundRobin})
})
t.Run("N-loop", func(t *testing.T) {
runServer(t, []string{"tcp://:9995", "tcp://:9996", "udp://:9997", "udp://:9998", "unix://" + testUnixAddr(t), "unix://" + testUnixAddr(t)}, &testConf{true, 0, true, true, false, false, 10, LeastConnections})
})
})
t.Run("sync-writev", func(t *testing.T) {
t.Run("1-loop", func(t *testing.T) {
runServer(t, []string{"tcp://:9991", "tcp://:9992", "unix://" + testUnixAddr(t), "unix://" + testUnixAddr(t)}, &testConf{true, 0, true, false, false, true, 10, RoundRobin})
})
t.Run("N-loop", func(t *testing.T) {
runServer(t, []string{"tcp://:9995", "tcp://:9996", "unix://" + testUnixAddr(t), "unix://" + testUnixAddr(t)}, &testConf{true, 0, true, true, false, true, 10, LeastConnections})
})
})
t.Run("async", func(t *testing.T) {
t.Run("1-loop", func(t *testing.T) {
runServer(t, []string{"tcp://:9991", "tcp://:9992", "udp://:9993", "udp://:9994", "unix://" + testUnixAddr(t), "unix://" + testUnixAddr(t)}, &testConf{true, 0, true, false, true, false, 10, RoundRobin})
})
t.Run("N-loop", func(t *testing.T) {
runServer(t, []string{"tcp://:9995", "tcp://:9996", "udp://:9997", "udp://:9998", "unix://" + testUnixAddr(t), "unix://" + testUnixAddr(t)}, &testConf{true, 0, true, true, true, false, 10, LeastConnections})
})
})
t.Run("async-writev", func(t *testing.T) {
t.Run("1-loop", func(t *testing.T) {
runServer(t, []string{"tcp://:9991", "tcp://:9992", "unix://" + testUnixAddr(t), "unix://" + testUnixAddr(t)}, &testConf{true, 0, true, false, true, true, 10, RoundRobin})
})
t.Run("N-loop", func(t *testing.T) {
runServer(t, []string{"tcp://:9995", "tcp://:9996", "unix://" + testUnixAddr(t), "unix://" + testUnixAddr(t)}, &testConf{true, 0, true, true, true, true, 10, LeastConnections})
})
})
})
}
type testServer struct {
*BuiltinEventEngine
tester *testing.T
eng Engine
addrs []string
multicore bool
async bool
writev bool
nclients int
started int32
connected int32
disconnected int32
clientActive int32
}
func (s *testServer) OnBoot(eng Engine) (action Action) {
s.eng = eng
if len(s.addrs) > 1 {
fd, err := s.eng.Dup()
assert.ErrorIsf(s.tester, err, errorx.ErrUnsupportedOp, "dup error")
assert.EqualValuesf(s.tester, -1, fd, "expected fd: -1, but got: %d", fd)
addr := s.addrs[rand.Intn(len(s.addrs))]
network, address, _ := parseProtoAddr(addr)
fd, err = s.eng.DupListener(network, address)
assert.NoErrorf(s.tester, err, "DupListener error")
assert.Greaterf(s.tester, fd, 2, "expected duplicated fd: > 2, but got: %d", fd)
assert.NoErrorf(s.tester, SysClose(fd), "close fd error")
// Test invalid input
fd, err = s.eng.DupListener("tcp", "abc")
assert.ErrorIsf(s.tester, err, errorx.ErrInvalidNetworkAddress, "expected ErrInvalidNetworkAddress")
assert.EqualValuesf(s.tester, -1, fd, "expected fd: -1, but got: %d", fd)
} else {
fd, err := s.eng.Dup()
assert.NoErrorf(s.tester, err, "Dup error")
assert.Greaterf(s.tester, fd, 2, "expected duplicated fd: > 2, but got: %d", fd)
assert.NoErrorf(s.tester, SysClose(fd), "close fd error")
}
return
}
func (s *testServer) OnOpen(c Conn) (out []byte, action Action) {
c.SetContext(c)
atomic.AddInt32(&s.connected, 1)
out = []byte("andypan\r\n")
assert.NotNil(s.tester, c.LocalAddr(), "nil local addr")
assert.NotNil(s.tester, c.RemoteAddr(), "nil remote addr")
return
}
func (s *testServer) OnShutdown(_ Engine) {
if len(s.addrs) > 1 {
fd, err := s.eng.Dup()
assert.ErrorIsf(s.tester, err, errorx.ErrUnsupportedOp, "dup error")
assert.EqualValuesf(s.tester, -1, fd, "expected fd: -1, but got: %d", fd)
addr := s.addrs[rand.Intn(len(s.addrs))]
network, address, _ := parseProtoAddr(addr)
fd, err = s.eng.DupListener(network, address)
assert.NoErrorf(s.tester, err, "DupListener error")
assert.Greaterf(s.tester, fd, 2, "expected duplicated fd: > 2, but got: %d", fd)
assert.NoErrorf(s.tester, SysClose(fd), "close fd error")
// Test invalid input
fd, err = s.eng.DupListener("tcp", "abc")
assert.ErrorIsf(s.tester, err, errorx.ErrInvalidNetworkAddress, "expected ErrInvalidNetworkAddress")
assert.EqualValuesf(s.tester, -1, fd, "expected fd: -1, but got: %d", fd)
} else {
fd, err := s.eng.Dup()
assert.NoErrorf(s.tester, err, "Dup error")
assert.Greaterf(s.tester, fd, 2, "expected duplicated fd: > 2, but got: %d", fd)
assert.NoErrorf(s.tester, SysClose(fd), "close fd error")
}
}
func (s *testServer) OnClose(c Conn, err error) (action Action) {
if err != nil {
logging.Debugf("error occurred on closed, %v\n", err)
}
assert.Equal(s.tester, c.Context(), c, "invalid context")
atomic.AddInt32(&s.disconnected, 1)
return
}
func (s *testServer) OnTraffic(c Conn) (action Action) {
if s.async {
buf := bbPool.Get()
n, err := c.WriteTo(buf)
assert.NoError(s.tester, err, "WriteTo error")
assert.Greater(s.tester, n, int64(0), "WriteTo error")
if c.LocalAddr().Network() == "tcp" || c.LocalAddr().Network() == "unix" {
err = goPool.DefaultWorkerPool.Submit(
func() {
if s.writev {
mid := buf.Len() / 2
bs := make([][]byte, 2)
bs[0] = buf.B[:mid]
bs[1] = buf.B[mid:]
err := c.AsyncWritev(bs, func(c Conn, err error) error {
if c.RemoteAddr() != nil {
logging.Debugf("conn=%s done writev: %v", c.RemoteAddr().String(), err)
}
bbPool.Put(buf)
return nil
})
assert.NoError(s.tester, err, "AsyncWritev error")
} else {
err := c.AsyncWrite(buf.Bytes(), func(c Conn, err error) error {
if c.RemoteAddr() != nil {
logging.Debugf("conn=%s done write: %v", c.RemoteAddr().String(), err)
}
bbPool.Put(buf)
return nil
})
assert.NoError(s.tester, err, "AsyncWritev error")
}
})
assert.NoError(s.tester, err)
return
} else if c.LocalAddr().Network() == "udp" {
err := goPool.DefaultWorkerPool.Submit(
func() {
err := c.AsyncWrite(buf.Bytes(), nil)
assert.NoError(s.tester, err, "AsyncWritev error")
})
assert.NoError(s.tester, err)
return
}
return
}
buf, err := c.Next(-1)
assert.NoError(s.tester, err, "reading data error")
var n int
if s.writev {
mid := len(buf) / 2
n, err = c.Writev([][]byte{buf[:mid], buf[mid:]})
} else {
n, err = c.Write(buf)
}
assert.NoError(s.tester, err, "writev error")
assert.EqualValues(s.tester, n, len(buf), "short writev")
// Only for code coverage of testing.
if !s.multicore {
assert.NoError(s.tester, c.Flush(), "flush error")
_ = c.Fd()
fd, err := c.Dup()
assert.NoError(s.tester, err, "dup error")
assert.Greaterf(s.tester, fd, 2, "expected fd: > 2, but got: %d", fd)
assert.NoError(s.tester, SysClose(fd), "close error")
// TODO(panjf2000): somehow these two system calls will fail with Unix Domain Socket,
// returning "invalid argument" error on macOS in Github actions intermittently,
// try to figure it out.
if c.LocalAddr().Network() == "unix" && runtime.GOOS == "darwin" {
_ = c.SetReadBuffer(streamLen)
_ = c.SetWriteBuffer(streamLen)
} else {
assert.NoError(s.tester, c.SetReadBuffer(streamLen), "set read buffer error")
assert.NoError(s.tester, c.SetWriteBuffer(streamLen), "set write buffer error")
}
if c.LocalAddr().Network() == "tcp" {
assert.NoError(s.tester, c.SetLinger(1), "set linger error")
assert.NoError(s.tester, c.SetNoDelay(false), "set no delay error")
assert.NoError(s.tester, c.SetKeepAlivePeriod(time.Minute), "set keepalive period error")
assert.EqualError(s.tester, c.SetKeepAlive(true, 0, 0, 0),
"invalid time duration", "set keepalive error")
assert.NoError(s.tester, c.SetKeepAlive(false, 0, 0, 0), "set keepalive error")
assert.NoError(s.tester, c.SetKeepAlive(true, time.Minute*10, time.Minute, 10), "set keepalive error")
} else {
assert.ErrorIs(s.tester, c.SetKeepAlivePeriod(time.Minute), errorx.ErrUnsupportedOp,
"non-TCP connection should not support keepalive")
assert.ErrorIs(s.tester, c.SetKeepAlive(true, 0, 0, 0), errorx.ErrUnsupportedOp,
"non-TCP connection should not support keepalive")
}
assert.Zero(s.tester, c.InboundBuffered(), "inbound buffer error")
assert.GreaterOrEqual(s.tester, c.OutboundBuffered(), 0, "outbound buffer error")
n, err := c.Discard(1)
assert.NoErrorf(s.tester, err, "discard error")
assert.Zerof(s.tester, n, "discard error")
assert.ErrorIs(s.tester, c.SetDeadline(time.Now().Add(time.Second)), errorx.ErrUnsupportedOp)
assert.ErrorIs(s.tester, c.SetReadDeadline(time.Now().Add(time.Second)), errorx.ErrUnsupportedOp)
assert.ErrorIs(s.tester, c.SetWriteDeadline(time.Now().Add(time.Second)), errorx.ErrUnsupportedOp)
if c.LocalAddr().Network() == "udp" {
n, err := c.Writev([][]byte{})
assert.ErrorIs(s.tester, err, errorx.ErrUnsupportedOp, "udp Writev error")
assert.Zero(s.tester, n, "udp Writev error")
err = c.AsyncWritev([][]byte{}, nil)
assert.ErrorIs(s.tester, err, errorx.ErrUnsupportedOp, "udp Writev error")
_, err = c.SendTo(buf, nil)
assert.ErrorIsf(s.tester, err, errorx.ErrInvalidNetworkAddress,
"got error: %v, expected error: %v", err, errorx.ErrInvalidNetworkAddress)
} else {
_, err = c.SendTo(buf, c.RemoteAddr())
assert.ErrorIsf(s.tester, err, errorx.ErrUnsupportedOp,
"got error: %v, expected error: %v", err, errorx.ErrUnsupportedOp)
}
}
return
}
func (s *testServer) OnTick() (delay time.Duration, action Action) {
delay = 100 * time.Millisecond
if atomic.CompareAndSwapInt32(&s.started, 0, 1) {
for _, protoAddr := range s.addrs {
proto, addr, err := parseProtoAddr(protoAddr)
assert.NoError(s.tester, err)
for i := 0; i < s.nclients; i++ {
atomic.AddInt32(&s.clientActive, 1)
err := goPool.DefaultWorkerPool.Submit(func() {
startClient(s.tester, proto, addr, s.multicore, s.async, 0, nil)
atomic.AddInt32(&s.clientActive, -1)
})
assert.NoError(s.tester, err)
}
}
}
if atomic.LoadInt32(&s.clientActive) == 0 {
var streamAddrs int
for _, addr := range s.addrs {
if !strings.HasPrefix(addr, "udp") {
streamAddrs++
}
}
streamConns := s.nclients * streamAddrs
disconnected := atomic.LoadInt32(&s.disconnected)
if int(disconnected) == streamConns && disconnected == atomic.LoadInt32(&s.connected) {
action = Shutdown
assert.EqualValues(s.tester, 0, s.eng.CountConnections())
}
}
return
}
func runServer(t *testing.T, addrs []string, conf *testConf) {
ts := &testServer{
tester: t,
addrs: addrs,
multicore: conf.multicore,
async: conf.async,
writev: conf.writev,
nclients: conf.clients,
}
var err error
if len(addrs) > 1 {
err = Rotate(ts,
addrs,
WithEdgeTriggeredIO(conf.et),
WithEdgeTriggeredIOChunk(conf.etChunk),
WithLockOSThread(conf.async),
WithMulticore(conf.multicore),
WithReusePort(conf.reuseport),
WithTicker(true),
WithTCPKeepAlive(time.Minute),
WithTCPKeepInterval(time.Second*10),
WithTCPKeepCount(10),
WithTCPNoDelay(TCPNoDelay),
WithLoadBalancing(conf.lb))
} else {
err = Run(ts,
addrs[0],
WithEdgeTriggeredIO(conf.et),
WithEdgeTriggeredIOChunk(conf.etChunk),
WithLockOSThread(conf.async),
WithMulticore(conf.multicore),
WithReusePort(conf.reuseport),
WithTicker(true),
WithTCPKeepAlive(time.Minute),
WithTCPKeepInterval(time.Second*10),
WithTCPKeepCount(10),
WithTCPNoDelay(TCPDelay),
WithLoadBalancing(conf.lb))
}
assert.NoError(t, err)
}
func startClient(t *testing.T, network, addr string, multicore, async bool, packetSize int, stallCh chan struct{}) {
c, err := net.Dial(network, addr)
assert.NoError(t, err)
defer c.Close() //nolint:errcheck
rd := bufio.NewReader(c)
if network != "udp" {
msg, err := rd.ReadBytes('\n')
assert.NoError(t, err)
assert.Equal(t, string(msg), "andypan\r\n", "bad header")
}
if stallCh != nil {
<-stallCh
}
duration := time.Duration((rand.Float64()*2+1)*float64(time.Second)) / 2
logging.Debugf("test duration: %v", duration)
start := time.Now()
if packetSize == 0 {
packetSize = streamLen
if network == "udp" {
packetSize = datagramLen
}
}
for time.Since(start) < duration {
reqData := make([]byte, packetSize)
_, err = crand.Read(reqData)
assert.NoError(t, err)
_, err = c.Write(reqData)
assert.NoError(t, err)
respData := make([]byte, len(reqData))
_, err = io.ReadFull(rd, respData)
assert.NoError(t, err)
if !async {
// assert.Equalf(t, reqData, respData, "response mismatch with protocol:%s, multi-core:%t, content of bytes: %d vs %d", network, multicore, string(reqData), string(respData))
assert.Equalf(
t,
reqData,
respData,
"response mismatch with protocol:%s, multi-core:%t, length of bytes: %d vs %d",
network,
multicore,
len(reqData),
len(respData),
)
}
}
}
func TestDefaultGnetServer(*testing.T) {
svr := BuiltinEventEngine{}
svr.OnBoot(Engine{})
svr.OnOpen(nil)
svr.OnClose(nil, nil)
svr.OnTraffic(nil)
svr.OnTick()
}
type testBadAddrServer struct {
*BuiltinEventEngine
}
func (t *testBadAddrServer) OnBoot(_ Engine) (action Action) {
return Shutdown
}
func TestBadAddresses(t *testing.T) {
events := new(testBadAddrServer)
err := Run(events, "tulip://howdy")
require.ErrorIs(t, err, errorx.ErrUnsupportedProtocol)
err = Run(events, "howdy")
require.ErrorIs(t, err, errorx.ErrInvalidNetworkAddress)
err = Run(events, "tcp://")
require.ErrorIs(t, err, errorx.ErrInvalidNetworkAddress)
err = Run(events, "tcp://localhost:8080/foo")
require.ErrorIs(t, err, errorx.ErrInvalidNetworkAddress)
err = Run(events, "unix://")
require.ErrorIs(t, err, errorx.ErrInvalidNetworkAddress)
err = Run(events, ":foo")
require.Error(t, err, "missing protocol scheme")
err = Run(events, "tcp://127.0.0.1\n")
require.Error(t, err, "invalid control character in URL")
}
func TestTick(t *testing.T) {
testTick("tcp", ":9989", t)
}
type testTickServer struct {
*BuiltinEventEngine
count int
}
func (t *testTickServer) OnTick() (delay time.Duration, action Action) {
delay = time.Millisecond * 10
if t.count == 25 {
action = Shutdown
return
}
t.count++
return
}
func testTick(network, addr string, t *testing.T) {
events := &testTickServer{}
start := time.Now()
opts := Options{Ticker: true}
err := Run(events, network+"://"+addr, WithOptions(opts))
require.NoError(t, err)
dur := time.Since(start)
if dur < 250&time.Millisecond || dur > time.Second {
t.Logf("bad ticker timing: %d", dur)
}
}
func TestWakeConn(t *testing.T) {
testWakeConn(t, "tcp", ":9990")
}
type testWakeConnServer struct {
*BuiltinEventEngine
tester *testing.T
network string
addr string
conn chan Conn
c Conn
wake bool
}
func (t *testWakeConnServer) OnOpen(c Conn) (out []byte, action Action) {
t.conn <- c
return
}
func (t *testWakeConnServer) OnClose(Conn, error) (action Action) {
action = Shutdown
return
}
func (t *testWakeConnServer) OnTraffic(c Conn) (action Action) {
_, _ = c.Write([]byte("Waking up."))
action = -1
return
}
func (t *testWakeConnServer) OnTick() (delay time.Duration, action Action) {
if !t.wake {
t.wake = true
delay = time.Millisecond * 100
err := goPool.DefaultWorkerPool.Submit(func() {
conn, err := net.Dial(t.network, t.addr)
assert.NoError(t.tester, err)
defer conn.Close() //nolint:errcheck
r := make([]byte, 10)
_, err = conn.Read(r)
assert.NoError(t.tester, err)
})
assert.NoError(t.tester, err)
return
}
t.c = <-t.conn
_ = t.c.Wake(func(c Conn, err error) error {
logging.Debugf("conn=%s done wake: %v", c.RemoteAddr().String(), err)
return nil
})
delay = time.Millisecond * 100
return
}
func testWakeConn(t *testing.T, network, addr string) {
currentLogger, currentFlusher := logging.GetDefaultLogger(), logging.GetDefaultFlusher()
t.Cleanup(func() {
logging.SetDefaultLoggerAndFlusher(currentLogger, currentFlusher) // restore
})
svr := &testWakeConnServer{tester: t, network: network, addr: addr, conn: make(chan Conn, 1)}
logger := zap.NewExample()
err := Run(svr, network+"://"+addr,
WithTicker(true),
WithNumEventLoop(2*runtime.NumCPU()),
WithLogger(logger.Sugar()),
WithSocketRecvBuffer(4*1024),
WithSocketSendBuffer(4*1024),
WithReadBufferCap(2000),
WithWriteBufferCap(2000))
assert.NoError(t, err)
_ = logger.Sync()
}
func TestShutdown(t *testing.T) {
testShutdown(t, "tcp", ":9991")
}
type testShutdownServer struct {
*BuiltinEventEngine
tester *testing.T
eng Engine
network string
addr string
count int
clients int32
N int
}
func (t *testShutdownServer) OnBoot(eng Engine) (action Action) {
t.eng = eng
return
}
func (t *testShutdownServer) OnOpen(Conn) (out []byte, action Action) {
assert.EqualValues(t.tester, atomic.AddInt32(&t.clients, 1), t.eng.CountConnections())
return
}
func (t *testShutdownServer) OnClose(Conn, error) (action Action) {
atomic.AddInt32(&t.clients, -1)
return
}
func (t *testShutdownServer) OnTick() (delay time.Duration, action Action) {
if t.count == 0 {
// start clients
for i := 0; i < t.N; i++ {
err := goPool.DefaultWorkerPool.Submit(func() {
conn, err := net.Dial(t.network, t.addr)
assert.NoError(t.tester, err)
defer conn.Close() //nolint:errcheck
_, err = conn.Read([]byte{0})
assert.Error(t.tester, err)
})
assert.NoError(t.tester, err)
}
} else if int(atomic.LoadInt32(&t.clients)) == t.N {
action = Shutdown
}
t.count++
delay = time.Second / 20
return
}
func testShutdown(t *testing.T, network, addr string) {
currentLogger, currentFlusher := logging.GetDefaultLogger(), logging.GetDefaultFlusher()
t.Cleanup(func() {
logging.SetDefaultLoggerAndFlusher(currentLogger, currentFlusher) // restore
})
events := &testShutdownServer{tester: t, network: network, addr: addr, N: 100}
logPath := filepath.Join(t.TempDir(), "gnet-test-shutdown.log")
err := Run(events, network+"://"+addr,
WithLogPath(logPath),
WithLogLevel(logging.WarnLevel),
WithTicker(true),
WithReadBufferCap(512),
WithWriteBufferCap(512))
assert.NoError(t, err)
assert.Equal(t, 0, int(events.clients), "did not close all clients")
}
func TestCloseActionError(t *testing.T) {
testCloseActionError(t, "tcp", ":9992")
}
type testCloseActionErrorServer struct {
*BuiltinEventEngine
tester *testing.T
network, addr string
action bool
}
func (t *testCloseActionErrorServer) OnClose(Conn, error) (action Action) {
action = Shutdown
return
}
func (t *testCloseActionErrorServer) OnTraffic(c Conn) (action Action) {
n := c.InboundBuffered()
buf := make([]byte, n)
m, err := c.Read(buf)
assert.NoError(t.tester, err)
assert.EqualValuesf(t.tester, n, m, "read %d bytes, expected %d", m, n)
n, err = c.Write(buf)
assert.NoError(t.tester, err)
assert.EqualValuesf(t.tester, m, n, "wrote %d bytes, expected %d", n, m)
action = Close
return
}
func (t *testCloseActionErrorServer) OnTick() (delay time.Duration, action Action) {
if !t.action {
t.action = true
delay = time.Millisecond * 100
err := goPool.DefaultWorkerPool.Submit(func() {
conn, err := net.Dial(t.network, t.addr)
assert.NoError(t.tester, err)
defer conn.Close() //nolint:errcheck
data := []byte("Hello World!")
_, _ = conn.Write(data)
_, err = conn.Read(data)
assert.NoError(t.tester, err)
})
assert.NoError(t.tester, err)
return
}
delay = time.Millisecond * 100
return
}
func testCloseActionError(t *testing.T, network, addr string) {
events := &testCloseActionErrorServer{tester: t, network: network, addr: addr}
err := Run(events, network+"://"+addr, WithTicker(true))
assert.NoError(t, err)
}
func TestShutdownActionError(t *testing.T) {
testShutdownActionError(t, "tcp", ":9993")
}
type testShutdownActionErrorServer struct {
*BuiltinEventEngine
tester *testing.T
network, addr string
action bool
}
func (t *testShutdownActionErrorServer) OnTraffic(c Conn) (action Action) {
buf, _ := c.Peek(-1)
_, _ = c.Write(buf)
_, _ = c.Discard(-1)
action = Shutdown
return
}
func (t *testShutdownActionErrorServer) OnTick() (delay time.Duration, action Action) {
if !t.action {
t.action = true
delay = time.Millisecond * 100
err := goPool.DefaultWorkerPool.Submit(func() {
conn, err := net.Dial(t.network, t.addr)
assert.NoError(t.tester, err)
defer conn.Close() //nolint:errcheck
data := []byte("Hello World!")
_, _ = conn.Write(data)
_, err = conn.Read(data)
assert.NoError(t.tester, err)
})
assert.NoError(t.tester, err)
return
}
delay = time.Millisecond * 100
return
}
func testShutdownActionError(t *testing.T, network, addr string) {
events := &testShutdownActionErrorServer{tester: t, network: network, addr: addr}
err := Run(events, network+"://"+addr, WithTicker(true))
assert.NoError(t, err)
}
func TestCloseActionOnOpen(t *testing.T) {
testCloseActionOnOpen(t, "tcp", ":9994")
}
type testCloseActionOnOpenServer struct {
*BuiltinEventEngine
tester *testing.T
network, addr string
action bool
}
func (t *testCloseActionOnOpenServer) OnOpen(Conn) (out []byte, action Action) {
action = Close
return
}
func (t *testCloseActionOnOpenServer) OnClose(Conn, error) (action Action) {
action = Shutdown
return
}
func (t *testCloseActionOnOpenServer) OnTick() (delay time.Duration, action Action) {
if !t.action {
t.action = true
delay = time.Millisecond * 100
err := goPool.DefaultWorkerPool.Submit(func() {
conn, err := net.Dial(t.network, t.addr)
assert.NoError(t.tester, err)
defer conn.Close() //nolint:errcheck
})
assert.NoError(t.tester, err)
return
}
delay = time.Millisecond * 100
return
}
func testCloseActionOnOpen(t *testing.T, network, addr string) {
events := &testCloseActionOnOpenServer{tester: t, network: network, addr: addr}
err := Run(events, network+"://"+addr, WithTicker(true))
assert.NoError(t, err)
}
func TestShutdownActionOnOpen(t *testing.T) {
testShutdownActionOnOpen(t, "tcp", ":9995")
}
type testShutdownActionOnOpenServer struct {
*BuiltinEventEngine
tester *testing.T
network, addr string
action bool
eng Engine
}
func (t *testShutdownActionOnOpenServer) OnOpen(Conn) (out []byte, action Action) {
action = Shutdown
return
}
func (t *testShutdownActionOnOpenServer) OnShutdown(e Engine) {
t.eng = e
fd, err := t.eng.Dup()
assert.Greaterf(t.tester, fd, 2, "expected fd: > 2, but got: %d", fd)
assert.NoErrorf(t.tester, err, "dup error")
assert.NoErrorf(t.tester, SysClose(fd), "close error")
logging.Debugf("dup fd: %d with error: %v\n", fd, err)
}
func (t *testShutdownActionOnOpenServer) OnTick() (delay time.Duration, action Action) {
if !t.action {
t.action = true
delay = time.Millisecond * 100
err := goPool.DefaultWorkerPool.Submit(func() {
conn, err := net.Dial(t.network, t.addr)
assert.NoError(t.tester, err)
defer conn.Close() //nolint:errcheck
})
assert.NoError(t.tester, err)
return
}
delay = time.Millisecond * 100
return
}
func testShutdownActionOnOpen(t *testing.T, network, addr string) {
events := &testShutdownActionOnOpenServer{tester: t, network: network, addr: addr}
err := Run(events, network+"://"+addr, WithTicker(true))
require.NoError(t, err)
_, err = events.eng.Dup()
require.ErrorIsf(t, err, errorx.ErrEngineInShutdown, "expected error: %v, but got: %v",
errorx.ErrEngineInShutdown, err)
}
func TestUDPShutdown(t *testing.T) {
testUDPShutdown(t, "udp4", ":9000")
}
type testUDPShutdownServer struct {
*BuiltinEventEngine
tester *testing.T
network string
addr string
tick bool
}
func (t *testUDPShutdownServer) OnTraffic(c Conn) (action Action) {
buf, _ := c.Peek(-1)
_, _ = c.Write(buf)
_, _ = c.Discard(-1)
action = Shutdown
return
}
func (t *testUDPShutdownServer) OnTick() (delay time.Duration, action Action) {
if !t.tick {
t.tick = true
delay = time.Millisecond * 100
err := goPool.DefaultWorkerPool.Submit(func() {
conn, err := net.Dial(t.network, t.addr)
assert.NoError(t.tester, err)
defer conn.Close() //nolint:errcheck
data := []byte("Hello World!")
_, err = conn.Write(data)
assert.NoError(t.tester, err)
_, err = conn.Read(data)
assert.NoError(t.tester, err)
})
assert.NoError(t.tester, err)
return
}
delay = time.Millisecond * 100
return
}
func testUDPShutdown(t *testing.T, network, addr string) {
svr := &testUDPShutdownServer{tester: t, network: network, addr: addr}
err := Run(svr, network+"://"+addr, WithTicker(true))
assert.NoError(t, err)
}
func TestCloseConnection(t *testing.T) {
testCloseConnection(t, "tcp", ":9996")
}
type testCloseConnectionServer struct {
*BuiltinEventEngine
tester *testing.T
network, addr string
action bool
}
func (t *testCloseConnectionServer) OnClose(Conn, error) (action Action) {
action = Shutdown
return
}
func (t *testCloseConnectionServer) OnTraffic(c Conn) (action Action) {
buf, _ := c.Peek(-1)
_, _ = c.Write(buf)
_, _ = c.Discard(-1)
err := goPool.DefaultWorkerPool.Submit(func() {
time.Sleep(time.Second)
err := c.CloseWithCallback(func(_ Conn, err error) error {
assert.ErrorIsf(t.tester, err, errorx.ErrEngineShutdown, "should be engine shutdown error")
return nil
})
assert.NoError(t.tester, err)
})
assert.NoError(t.tester, err)
return
}
func (t *testCloseConnectionServer) OnTick() (delay time.Duration, action Action) {
delay = time.Millisecond * 100
if !t.action {
t.action = true
err := goPool.DefaultWorkerPool.Submit(func() {
conn, err := net.Dial(t.network, t.addr)
assert.NoError(t.tester, err)
defer conn.Close() //nolint:errcheck
data := []byte("Hello World!")
_, _ = conn.Write(data)
_, err = conn.Read(data)
assert.NoError(t.tester, err)
// waiting the engine shutdown.
_, err = conn.Read(data)
assert.Error(t.tester, err)
})
assert.NoError(t.tester, err)
return
}
return
}
func testCloseConnection(t *testing.T, network, addr string) {
events := &testCloseConnectionServer{tester: t, network: network, addr: addr}
err := Run(events, network+"://"+addr, WithTicker(true))
assert.NoError(t, err)
}
func TestServerOptionsCheck(t *testing.T) {
err := Run(&BuiltinEventEngine{}, "tcp://:3500", WithNumEventLoop(10001), WithLockOSThread(true))
assert.ErrorIs(t, err, errorx.ErrTooManyEventLoopThreads, "error returned with LockOSThread option")
}
func TestStopServer(t *testing.T) {
testStop(t, "tcp", ":9997")
}
type testStopServer struct {
*BuiltinEventEngine
tester *testing.T
network, addr, protoAddr string
eng Engine
action bool
}
func (t *testStopServer) OnBoot(eng Engine) (action Action) {
t.eng = eng
return
}
func (t *testStopServer) OnClose(Conn, error) (action Action) {
logging.Debugf("closing connection...")
return
}
func (t *testStopServer) OnTraffic(c Conn) (action Action) {
buf, _ := c.Peek(-1)
_, _ = c.Write(buf)
_, _ = c.Discard(-1)
return
}
func (t *testStopServer) OnTick() (delay time.Duration, action Action) {
delay = time.Millisecond * 100
if !t.action {
t.action = true
err := goPool.DefaultWorkerPool.Submit(func() {
conn, err := net.Dial(t.network, t.addr)
assert.NoError(t.tester, err)
defer conn.Close() //nolint:errcheck
data := []byte("Hello World!")
_, _ = conn.Write(data)
_, err = conn.Read(data)
assert.NoError(t.tester, err)
err = goPool.DefaultWorkerPool.Submit(func() {
ctx, cancel := context.WithTimeout(context.Background(), 3*time.Second)
defer cancel()
logging.Debugf("stop engine...", t.eng.Stop(ctx))
})
assert.NoError(t.tester, err)
// waiting the engine shutdown.
_, err = conn.Read(data)
assert.Error(t.tester, err)
})
assert.NoError(t.tester, err)
return
}
return
}
func testStop(t *testing.T, network, addr string) {
events := &testStopServer{tester: t, network: network, addr: addr, protoAddr: network + "://" + addr}
err := Run(events, events.protoAddr, WithTicker(true))
assert.NoError(t, err)
}
func TestEngineStop(t *testing.T) {
testEngineStop(t, "tcp", ":9998")
}
type testStopEngine struct {
*BuiltinEventEngine
tester *testing.T
network, addr, protoAddr string
eng Engine
stopIter int64
name string
exchngCount int64
}
func (t *testStopEngine) OnBoot(eng Engine) (action Action) {
t.eng = eng
return
}
func (t *testStopEngine) OnClose(Conn, error) (action Action) {
logging.Debugf("closing connection...")
return
}
func (t *testStopEngine) OnTraffic(c Conn) (action Action) {
buf, _ := c.Peek(-1)
_, _ = c.Write(buf)
_, _ = c.Discard(-1)
atomic.AddInt64(&t.exchngCount, 1)
return
}
func (t *testStopEngine) OnTick() (delay time.Duration, action Action) {
delay = time.Millisecond * 100
err := goPool.DefaultWorkerPool.Submit(func() {
conn, err := net.Dial(t.network, t.addr)
assert.NoError(t.tester, err)
defer conn.Close() //nolint:errcheck
data := []byte("Hello World! " + t.name)
_, _ = conn.Write(data)
_, err = conn.Read(data)
assert.NoError(t.tester, err)
iter := atomic.LoadInt64(&t.stopIter)
if iter <= 0 {
ctx, cancel := context.WithTimeout(context.Background(), 3*time.Second)
defer cancel()
logging.Debugf("stop engine...", t.eng.Stop(ctx))
// waiting the engine shutdown.
_, err = conn.Read(data)
assert.Error(t.tester, err)
}
atomic.AddInt64(&t.stopIter, -1)
})
assert.NoError(t.tester, err)
return
}
func testEngineStop(t *testing.T, network, addr string) {
events1 := &testStopEngine{tester: t, network: network, addr: addr, protoAddr: network + "://" + addr, name: "1", stopIter: 2}
events2 := &testStopEngine{tester: t, network: network, addr: addr, protoAddr: network + "://" + addr, name: "2", stopIter: 5}
result1 := make(chan error, 1)
err := goPool.DefaultWorkerPool.Submit(func() {
err := Run(events1, events1.protoAddr, WithTicker(true), WithReuseAddr(true), WithReusePort(true))
result1 <- err
})
require.NoError(t, err)
// ensure the first handler processes before starting the next since the delay per tick is 100ms
time.Sleep(150 * time.Millisecond)
result2 := make(chan error, 1)
err = goPool.DefaultWorkerPool.Submit(func() {
err := Run(events2, events2.protoAddr, WithTicker(true), WithReuseAddr(true), WithReusePort(true))
result2 <- err
})
require.NoError(t, err)
err = <-result1
require.NoError(t, err)
err = <-result2
require.NoError(t, err)
// make sure that each handler processed at least 1
require.Greater(t, events1.exchngCount, int64(0))
require.Greater(t, events2.exchngCount, int64(0))
require.Equal(t, int64(2+1+5+1), events1.exchngCount+events2.exchngCount)
// stop an already stopped engine
require.Equal(t, errorx.ErrEngineInShutdown, events1.eng.Stop(context.Background()))
}
// Test should not panic when we wake up server_closed conn.
func TestClosedWakeUp(t *testing.T) {
events := &testClosedWakeUpServer{
tester: t,
BuiltinEventEngine: &BuiltinEventEngine{}, network: "tcp", addr: ":9999", protoAddr: "tcp://:9999",
clientClosed: make(chan struct{}),
serverClosed: make(chan struct{}),
wakeup: make(chan struct{}),
}
err := Run(events, events.protoAddr)
assert.NoError(t, err)
}
type testClosedWakeUpServer struct {
*BuiltinEventEngine
tester *testing.T
network, addr, protoAddr string
wakeup chan struct{}
serverClosed chan struct{}
clientClosed chan struct{}
}
func (s *testClosedWakeUpServer) OnBoot(eng Engine) (action Action) {
err := goPool.DefaultWorkerPool.Submit(func() {
c, err := net.Dial(s.network, s.addr)
assert.NoError(s.tester, err)
_, err = c.Write([]byte("hello"))
assert.NoError(s.tester, err)
<-s.wakeup
_, err = c.Write([]byte("hello again"))
assert.NoError(s.tester, err)
close(s.clientClosed)
<-s.serverClosed
logging.Debugf("stop engine...", eng.Stop(context.TODO()))
})
assert.NoError(s.tester, err)
return None
}
func (s *testClosedWakeUpServer) OnTraffic(c Conn) Action {
assert.NotNil(s.tester, c.RemoteAddr())
select {
case <-s.wakeup:
default:
close(s.wakeup)
}
err := goPool.DefaultWorkerPool.Submit(func() { assert.NoError(s.tester, c.Wake(nil)) })
assert.NoError(s.tester, err)
err = goPool.DefaultWorkerPool.Submit(func() { assert.NoError(s.tester, c.Close()) })
assert.NoError(s.tester, err)
<-s.clientClosed
_, _ = c.Write([]byte("answer"))
return None
}
func (s *testClosedWakeUpServer) OnClose(Conn, error) (action Action) {
select {
case <-s.serverClosed:
default:
close(s.serverClosed)
}
return
}
type testMultiInstLoggerRaceServer struct {
*BuiltinEventEngine
}
func (t *testMultiInstLoggerRaceServer) OnBoot(_ Engine) (action Action) {
return Shutdown
}
func TestMultiInstLoggerRace(t *testing.T) {
currentLogger, currentFlusher := logging.GetDefaultLogger(), logging.GetDefaultFlusher()
t.Cleanup(func() {
logging.SetDefaultLoggerAndFlusher(currentLogger, currentFlusher) // restore
})
logger1, _ := zap.NewDevelopment()
events1 := new(testMultiInstLoggerRaceServer)
g := errgroup.Group{}
g.Go(func() error {
err := Run(events1, "tulip://howdy", WithLogger(logger1.Sugar()))
return err
})
logger2, _ := zap.NewDevelopment()
events2 := new(testMultiInstLoggerRaceServer)
g.Go(func() error {
err := Run(events2, "tulip://howdy", WithLogger(logger2.Sugar()))
return err
})
assert.ErrorIs(t, g.Wait(), errorx.ErrUnsupportedProtocol)
}
type testDisconnectedAsyncWriteServer struct {
BuiltinEventEngine
tester *testing.T
addr string
writev, clientStarted bool
exit atomic.Bool
}
func (t *testDisconnectedAsyncWriteServer) OnTraffic(c Conn) Action {
_, err := c.Next(0)
assert.NoErrorf(t.tester, err, "c.Next error: %v", err)
err = goPool.DefaultWorkerPool.Submit(func() {
for range time.Tick(100 * time.Millisecond) {
if t.exit.Load() {
break
}
var err error
if t.writev {
err = c.AsyncWritev([][]byte{[]byte("hello"), []byte("hello")}, func(_ Conn, err error) error {
if err == nil {
return nil
}
assert.ErrorIsf(t.tester, err, net.ErrClosed, "expected error: %v, but got: %v", net.ErrClosed, err)
t.exit.Store(true)
return nil
})
} else {
err = c.AsyncWrite([]byte("hello"), func(_ Conn, err error) error {
if err == nil {
return nil
}
assert.ErrorIsf(t.tester, err, net.ErrClosed, "expected error: %v, but got: %v", net.ErrClosed, err)
t.exit.Store(true)
return nil
})
}
if err != nil {
return
}
}
})
assert.NoError(t.tester, err)
return None
}
func (t *testDisconnectedAsyncWriteServer) OnTick() (delay time.Duration, action Action) {
delay = 500 * time.Millisecond
if t.exit.Load() {
action = Shutdown
return
}
if !t.clientStarted {
t.clientStarted = true
err := goPool.DefaultWorkerPool.Submit(func() {
c, err := net.Dial("tcp", t.addr)
assert.NoError(t.tester, err)
_, err = c.Write([]byte("hello"))
assert.NoError(t.tester, err)
assert.NoError(t.tester, c.Close())
})
assert.NoError(t.tester, err)
}
return
}
func TestDisconnectedAsyncWrite(t *testing.T) {
t.Run("async-write", func(t *testing.T) {
events := &testDisconnectedAsyncWriteServer{tester: t, addr: ":10000"}
err := Run(events, "tcp://:10000", WithTicker(true))
assert.NoError(t, err)
})
t.Run("async-writev", func(t *testing.T) {
events := &testDisconnectedAsyncWriteServer{tester: t, addr: ":10001", writev: true}
err := Run(events, "tcp://:10001", WithTicker(true))
assert.NoError(t, err)
})
}
var errIncompletePacket = errors.New("incomplete packet")
type simServer struct {
BuiltinEventEngine
tester *testing.T
eng Engine
network string
addr string
multicore bool
nclients int
packetSize int
batchWrite int
batchRead int
started int32
connected int32
disconnected int32
}
func (s *simServer) OnBoot(eng Engine) (action Action) {
s.eng = eng
return
}
func (s *simServer) OnOpen(c Conn) (out []byte, action Action) {
c.SetContext(&testCodec{})
atomic.AddInt32(&s.connected, 1)
out = []byte("andypan\r\n")
assert.NotNil(s.tester, c.LocalAddr(), "nil local addr")
assert.NotNil(s.tester, c.RemoteAddr(), "nil remote addr")
return
}
func (s *simServer) OnClose(_ Conn, err error) (action Action) {
if err != nil {
logging.Debugf("error occurred on closed, %v\n", err)
}
atomic.AddInt32(&s.disconnected, 1)
if atomic.LoadInt32(&s.connected) == atomic.LoadInt32(&s.disconnected) &&
atomic.LoadInt32(&s.disconnected) == int32(s.nclients) {
action = Shutdown
}
return
}
func (s *simServer) OnTraffic(c Conn) (action Action) {
codec := c.Context().(*testCodec)
var packets [][]byte
for i := 0; i < s.batchRead; i++ {
data, err := codec.Decode(c)
if errors.Is(err, errIncompletePacket) {
break
}
if err != nil {
logging.Errorf("invalid packet: %v", err)
return Close
}
packet, _ := codec.Encode(data)
packets = append(packets, packet)
}
if n := len(packets); n > 1 {
_, _ = c.Writev(packets)
} else if n == 1 {
_, _ = c.Write(packets[0])
}
if len(packets) == s.batchRead && c.InboundBuffered() > 0 {
err := c.Wake(nil) // wake up the connection manually to avoid missing the leftover data
assert.NoError(s.tester, err)
}
return
}
func (s *simServer) OnTick() (delay time.Duration, action Action) {
if atomic.CompareAndSwapInt32(&s.started, 0, 1) {
for i := 0; i < s.nclients; i++ {
err := goPool.DefaultWorkerPool.Submit(func() {
runSimClient(s.tester, s.network, s.addr, s.packetSize, s.batchWrite)
})
assert.NoError(s.tester, err)
}
}
delay = 100 * time.Millisecond
return
}
// All current protocols.
const (
magicNumber = 1314
magicNumberSize = 2
bodySize = 4
)
var magicNumberBytes []byte
func init() {
magicNumberBytes = make([]byte, magicNumberSize)
binary.BigEndian.PutUint16(magicNumberBytes, uint16(magicNumber))
}
// Protocol format:
//
// * 0 2 6
// * +-----------+-----------------------+
// * | magic | body len |
// * +-----------+-----------+-----------+
// * | |
// * + +
// * | body bytes |
// * + +
// * | ... ... |
// * +-----------------------------------+.
type testCodec struct{}
func (codec testCodec) Encode(buf []byte) ([]byte, error) {
bodyOffset := magicNumberSize + bodySize
msgLen := bodyOffset + len(buf)
data := make([]byte, msgLen)
copy(data, magicNumberBytes)
binary.BigEndian.PutUint32(data[magicNumberSize:bodyOffset], uint32(len(buf)))
copy(data[bodyOffset:msgLen], buf)
return data, nil
}
func (codec testCodec) Decode(c Conn) ([]byte, error) {
bodyOffset := magicNumberSize + bodySize
buf, err := c.Peek(bodyOffset)
if err != nil {
if errors.Is(err, io.ErrShortBuffer) {
err = errIncompletePacket
}
return nil, err
}
if !bytes.Equal(magicNumberBytes, buf[:magicNumberSize]) {
return nil, errors.New("invalid magic number")
}
bodyLen := binary.BigEndian.Uint32(buf[magicNumberSize:bodyOffset])
msgLen := bodyOffset + int(bodyLen)
buf, err = c.Peek(msgLen)
if err != nil {
if errors.Is(err, io.ErrShortBuffer) {
err = errIncompletePacket
}
return nil, err
}
body := make([]byte, bodyLen)
copy(body, buf[bodyOffset:msgLen])
_, _ = c.Discard(msgLen)
return body, nil
}
func (codec testCodec) Unpack(buf []byte) ([]byte, error) {
bodyOffset := magicNumberSize + bodySize
if len(buf) < bodyOffset {
return nil, errIncompletePacket
}
if !bytes.Equal(magicNumberBytes, buf[:magicNumberSize]) {
return nil, errors.New("invalid magic number")
}
bodyLen := binary.BigEndian.Uint32(buf[magicNumberSize:bodyOffset])
msgLen := bodyOffset + int(bodyLen)
if len(buf) < msgLen {
return nil, errIncompletePacket
}
return buf[bodyOffset:msgLen], nil
}
func TestSimServer(t *testing.T) {
t.Run("packet-size=64,batch=200", func(t *testing.T) {
runSimServer(t, ":7200", true, 10, 64, 200, -1)
})
t.Run("packet-size=128,batch=100", func(t *testing.T) {
runSimServer(t, ":7201", false, 10, 128, 100, 10)
})
t.Run("packet-size=256,batch=50", func(t *testing.T) {
runSimServer(t, ":7202", true, 10, 256, 50, -1)
})
t.Run("packet-size=512,batch=30", func(t *testing.T) {
runSimServer(t, ":7203", false, 10, 512, 30, 3)
})
t.Run("packet-size=1024,batch=20", func(t *testing.T) {
runSimServer(t, ":7204", true, 10, 1024, 20, -1)
})
t.Run("packet-size=64*1024,batch=10", func(t *testing.T) {
runSimServer(t, ":7205", false, 10, 64*1024, 10, 1)
})
t.Run("packet-size=128*1024,batch=5", func(t *testing.T) {
runSimServer(t, ":7206", true, 10, 128*1024, 5, -1)
})
t.Run("packet-size=512*1024,batch=3", func(t *testing.T) {
runSimServer(t, ":7207", false, 10, 512*1024, 3, 1)
})
t.Run("packet-size=1024*1024,batch=2", func(t *testing.T) {
runSimServer(t, ":7208", true, 10, 1024*1024, 2, -1)
})
}
func runSimServer(t *testing.T, addr string, et bool, nclients, packetSize, batchWrite, batchRead int) {
ts := &simServer{
tester: t,
network: "tcp",
addr: addr,
multicore: true,
nclients: nclients,
packetSize: packetSize,
batchWrite: batchWrite,
batchRead: batchRead,
}
if batchRead < 0 {
ts.batchRead = math.MaxInt32 // unlimited read batch
}
err := Run(ts,
ts.network+"://"+ts.addr,
WithEdgeTriggeredIO(et),
WithMulticore(ts.multicore),
WithTicker(true),
WithTCPKeepAlive(time.Minute),
WithTCPKeepInterval(time.Second*10),
WithTCPKeepCount(10),
)
assert.NoError(t, err)
}
func runSimClient(t *testing.T, network, addr string, packetSize, batch int) {
c, err := net.Dial(network, addr)
assert.NoError(t, err)
defer c.Close() //nolint:errcheck
rd := bufio.NewReader(c)
msg, err := rd.ReadBytes('\n')
assert.NoError(t, err)
assert.Equal(t, string(msg), "andypan\r\n", "bad header")
var duration time.Duration
packetBytes := packetSize * batch
switch {
case packetBytes < 16*1024:
duration = 2 * time.Second
case packetBytes < 32*1024:
duration = 3 * time.Second
case packetBytes < 480*1024:
duration = 4 * time.Second
default:
duration = 5 * time.Second
}
logging.Debugf("test duration: %v", duration)
start := time.Now()
for time.Since(start) < duration {
batchSendAndRecv(t, c, rd, packetSize, batch)
}
}
func batchSendAndRecv(t *testing.T, c net.Conn, rd *bufio.Reader, packetSize, batch int) {
codec := testCodec{}
var (
requests [][]byte
buf []byte
packetLen int
)
for i := 0; i < batch; i++ {
req := make([]byte, packetSize)
_, err := crand.Read(req)
assert.NoError(t, err)
requests = append(requests, req)
packet, _ := codec.Encode(req)
packetLen = len(packet)
buf = append(buf, packet...)
}
_, err := c.Write(buf)
assert.NoError(t, err)
respPacket := make([]byte, batch*packetLen)
_, err = io.ReadFull(rd, respPacket)
assert.NoError(t, err)
for i, req := range requests {
rsp, err := codec.Unpack(respPacket[i*packetLen:])
assert.NoError(t, err)
assert.Equalf(t, req, rsp, "request and response mismatch, packet size: %d, batch: %d, round: %d",
packetSize, batch, i)
}
}
type testUDPSendtoServer struct {
BuiltinEventEngine
addr string
tester *testing.T
startClientsOnce sync.Once
broadcastMsg []byte
mu sync.Mutex
clientAddrs []net.Addr
clientCount int
}
func (t *testUDPSendtoServer) OnBoot(_ Engine) (action Action) {
t.broadcastMsg = []byte("Broadcasting message")
t.clientCount = 10
return
}
func (t *testUDPSendtoServer) OnTraffic(c Conn) Action {
msg, err := c.Next(-1)
assert.NoErrorf(t.tester, err, "c.Next error: %v", err)
assert.NotZero(t.tester, msg, "c.Next should not return empty buffer")
t.mu.Lock()
t.clientAddrs = append(t.clientAddrs, c.RemoteAddr())
if len(t.clientAddrs) == t.clientCount {
for _, addr := range t.clientAddrs {
n, err := c.SendTo(t.broadcastMsg, addr)
assert.NoError(t.tester, err, "c.SendTo error")
assert.EqualValuesf(t.tester, len(t.broadcastMsg), n,
"c.SendTo should send %d bytes, but sent %d bytes", len(t.broadcastMsg), n)
}
}
t.mu.Unlock()
return None
}
func (t *testUDPSendtoServer) OnTick() (delay time.Duration, action Action) {
t.startClientsOnce.Do(func() {
for i := 0; i < t.clientCount; i++ {
err := goPool.DefaultWorkerPool.Submit(func() {
c, err := net.Dial("udp", t.addr)
assert.NoError(t.tester, err)
defer c.Close() //nolint:errcheck
_, err = c.Write([]byte("Hello World!"))
assert.NoError(t.tester, err)
msg := make([]byte, len(t.broadcastMsg))
_, err = c.Read(msg)
assert.NoError(t.tester, err)
assert.EqualValuesf(t.tester, msg, t.broadcastMsg,
"broadcast message mismatch, expected: %s, got: %s", t.broadcastMsg, msg)
t.mu.Lock()
t.clientCount--
t.mu.Unlock()
})
assert.NoError(t.tester, err)
}
})
t.mu.Lock()
if t.clientCount == 0 {
action = Shutdown
}
t.mu.Unlock()
delay = time.Millisecond * 100
return
}
func TestUDPSendtoServer(t *testing.T) {
// The listening address without an explicit IP works on Linux and Windows
// while sendto fails on macOS with EINVAL (invalid argument) that might
// also occur on more BSD systems: FreeBSD, OpenBSD, NetBSD, and DragonflyBSD.
// To pass this test on all platforms, specify an explicit IP address here.
// addr := ":10000"
addr := "127.0.0.1:10000"
events := &testUDPSendtoServer{tester: t, addr: addr}
err := Run(events, "udp://"+addr, WithTicker(true))
assert.NoError(t, err)
}
func startUDPEchoServer(t *testing.T, c *net.UDPConn) {
defer c.Close() //nolint:errcheck
buf := make([]byte, datagramLen)
for {
nr, remote, err := c.ReadFromUDP(buf)
if err != nil {
break
}
if nr > 0 {
nw, err := c.WriteToUDP(buf[:nr], remote)
assert.EqualValuesf(t, nr, nw, "UDP echo server should send %d bytes, but sent %d bytes", nr, nw)
assert.NoErrorf(t, err, "error occurred on UDP echo server %v write to %s, %v",
remote, c.LocalAddr().String(), err)
}
}
}
func startStreamEchoServer(t *testing.T, ln net.Listener) {
defer func() {
ln.Close() //nolint:errcheck
if strings.HasPrefix(ln.Addr().Network(), "unix") {
os.Remove(ln.Addr().String()) //nolint:errcheck
}
}()
for {
c, err := ln.Accept()
if err != nil {
return
}
err = goPool.DefaultWorkerPool.Submit(func() {
defer c.Close() //nolint:errcheck
buf := make([]byte, streamLen)
for {
nr, err := c.Read(buf)
if err != nil {
break
}
b := buf[:nr]
for len(b) > 0 {
nw, err := c.Write(b)
assert.NoErrorf(t, err, "error occurred on TCP echo server %s write to %s, %v",
ln.Addr().String(), c.RemoteAddr().String(), err)
b = b[nw:]
}
}
})
assert.NoError(t, err, "error occurred on TCP echo server %s submit task, %v",
ln.Addr().String(), err)
}
}
type streamProxyServer struct {
BuiltinEventEngine
engine Engine
eventLoop EventLoop
stallCh chan struct{}
tester *testing.T
ListenerNet string
ListenerAddr string
connected int32
disconnected int32
backendEstablished int32
backendServerPoolMu sync.Mutex
backendServerPool []string
startClintOnce sync.Once
backendServers []string
packetSize int
}
func (p *streamProxyServer) OnShutdown(eng Engine) {
p.engine = eng
p.tester.Logf("proxy server %s shutdown!", p.ListenerAddr)
}
func (p *streamProxyServer) OnOpen(c Conn) (out []byte, action Action) {
if c.LocalAddr().String() == p.ListenerAddr { // it's a server connection
out = []byte("andypan\r\n")
p.backendServerPoolMu.Lock()
backendServer := p.backendServerPool[len(p.backendServerPool)-1]
p.backendServerPool = p.backendServerPool[:len(p.backendServerPool)-1]
p.backendServerPoolMu.Unlock()
// Test the error handling of the methods of EventLoop.
_, err := c.EventLoop().Register(context.Background(), nil)
assert.ErrorIsf(p.tester, err, errorx.ErrInvalidNetworkAddress, "Expected error: %v, but got: %v",
errorx.ErrInvalidNetworkAddress, err)
_, err = c.EventLoop().Enroll(context.Background(), nil)
assert.ErrorIsf(p.tester, err, errorx.ErrInvalidNetConn, "Expected error: %v, but got: %v",
errorx.ErrInvalidNetConn, err)
err = c.EventLoop().Execute(context.Background(), nil)
assert.ErrorIsf(p.tester, err, errorx.ErrNilRunnable, "Expected error: %v, but got: %v",
errorx.ErrNilRunnable, err)
err = c.EventLoop().Schedule(context.Background(), nil, time.Millisecond)
assert.ErrorIsf(p.tester, err, errorx.ErrUnsupportedOp, "Expected error: %v, but got: %v",
errorx.ErrUnsupportedOp, err)
network, addr, err := parseProtoAddr(backendServer)
assert.NoError(p.tester, err, "parseProtoAddr error")
var address net.Addr
switch {
case strings.HasPrefix(network, "tcp"):
address, err = net.ResolveTCPAddr(network, addr)
case strings.HasPrefix(network, "udp"):
address, err = net.ResolveUDPAddr(network, addr)
case strings.HasPrefix(network, "unix"):
address, err = net.ResolveUnixAddr(network, addr)
default:
assert.Failf(p.tester, "unsupported protocol", "unsupported protocol: %s", network)
}
assert.NoError(p.tester, err, "ResolveNetAddr error")
ctx := NewContext(context.Background(), c)
resCh, err := c.EventLoop().Register(ctx, address)
assert.NoError(p.tester, err, "Register connection error")
err = goPool.DefaultWorkerPool.Submit(func() {
res := <-resCh
assert.NoError(p.tester, res.Err, "Register connection error")
assert.NotNil(p.tester, res.Conn, "Register connection nil")
})
assert.NoError(p.tester, err, "Submit task error")
atomic.AddInt32(&p.connected, 1)
} else { // it's a client connection
// Store the client connection in the context of the server connection.
serverConn, ok := c.Context().(Conn)
assert.True(p.tester, ok, "context is not Conn")
assert.NotNil(p.tester, serverConn, "context is not Conn")
serverConn.SetContext(c)
err := c.EventLoop().Execute(NewContext(context.Background(), c.LocalAddr()),
RunnableFunc(func(ctx context.Context) error {
p.tester.Logf("backend connection %v established", FromContext(ctx))
return nil
}))
assert.NoError(p.tester, err, "Execute task error")
if int(atomic.AddInt32(&p.backendEstablished, 1)) == len(p.backendServers) {
// Unlock the clients to start sending data.
close(p.stallCh)
}
}
return
}
func (p *streamProxyServer) OnClose(c Conn, err error) (action Action) {
connType := "client"
if c.LocalAddr().String() == p.ListenerAddr {
connType = "server"
}
logging.Debugf("closing %s connection: %s", connType, c.LocalAddr().String())
if err != nil {
logging.Debugf("error occurred on server connnection closing, %v", err)
}
if c.LocalAddr().String() == p.ListenerAddr { // it's a server connection
pc, ok := c.Context().(Conn)
assert.True(p.tester, ok, "server context connection is nil")
assert.NotNil(p.tester, pc, "server context connection is nil")
err := c.EventLoop().Close(pc) // close the corresponding client connection
assert.NoError(p.tester, err, "Close client connection error")
if disconnected := atomic.AddInt32(&p.disconnected, 1); int(disconnected) == len(p.backendServers) &&
disconnected == atomic.LoadInt32(&p.connected) {
p.eventLoop = c.EventLoop()
action = Shutdown
}
}
return
}
func (p *streamProxyServer) OnTraffic(c Conn) Action {
connType := "client"
if c.LocalAddr().String() == p.ListenerAddr {
connType = "server"
}
pc, ok := c.Context().(Conn)
if !ok {
// The backend connection is not established yet, retry later.
assert.NoError(p.tester, c.Wake(nil), "Wake connection error")
return None
}
_, err := c.WriteTo(pc)
assert.NoErrorf(p.tester, err, "%s: Write error from %s to %s",
connType, c.LocalAddr().String(), pc.RemoteAddr().String())
return None
}
func (p *streamProxyServer) OnTick() (time.Duration, Action) {
p.startClintOnce.Do(func() {
for i := 0; i < len(p.backendServers); i++ {
err := goPool.DefaultWorkerPool.Submit(func() {
startClient(p.tester, p.ListenerNet, p.ListenerAddr,
true, false, p.packetSize, p.stallCh)
})
assert.NoErrorf(p.tester, err, "Submit backend server %s error: %v", p.ListenerAddr, err)
}
})
return time.Millisecond * 200, None
}
func TestStreamProxyServer(t *testing.T) {
t.Run("tcp-proxy-server", func(t *testing.T) {
addr := "tcp://127.0.0.1:10000"
backendServers := []string{
"tcp://127.0.0.1:10001",
"tcp://127.0.0.1:10002",
"tcp://127.0.0.1:10003",
"tcp://127.0.0.1:10004",
"tcp://127.0.0.1:10005",
"tcp://127.0.0.1:10006",
"tcp://127.0.0.1:10007",
"tcp://127.0.0.1:10008",
"tcp://127.0.0.1:10009",
"tcp://127.0.0.1:10010",
}
t.Run("1-loop-LT", func(t *testing.T) {
testStreamProxyServer(t, addr, backendServers, false, false)
})
t.Run("1-loop-ET", func(t *testing.T) {
testStreamProxyServer(t, addr, backendServers, false, true)
})
t.Run("N-loop-LT", func(t *testing.T) {
testStreamProxyServer(t, addr, backendServers, true, false)
})
t.Run("N-loop-ET", func(t *testing.T) {
testStreamProxyServer(t, addr, backendServers, true, true)
})
})
t.Run("unix-proxy-server", func(t *testing.T) {
addr := "unix://unix-proxy-server.sock"
backendServers := []string{
"unix://unix-proxy-server-1.sock",
"unix://unix-proxy-server-2.sock",
"unix://unix-proxy-server-3.sock",
"unix://unix-proxy-server-4.sock",
"unix://unix-proxy-server-5.sock",
"unix://unix-proxy-server-6.sock",
"unix://unix-proxy-server-7.sock",
"unix://unix-proxy-server-8.sock",
"unix://unix-proxy-server-9.sock",
"unix://unix-proxy-server-10.sock",
}
t.Run("1-loop-LT", func(t *testing.T) {
testStreamProxyServer(t, addr, backendServers, false, false)
})
t.Run("1-loop-ET", func(t *testing.T) {
testStreamProxyServer(t, addr, backendServers, false, true)
})
t.Run("N-loop-LT", func(t *testing.T) {
testStreamProxyServer(t, addr, backendServers, true, false)
})
t.Run("N-loop-ET", func(t *testing.T) {
testStreamProxyServer(t, addr, backendServers, true, true)
})
})
t.Run("udp-proxy-server", func(t *testing.T) {
addr := "tcp://127.0.0.1:11000"
backendServers := []string{
"udp://127.0.0.1:11001",
"udp://127.0.0.1:11002",
"udp://127.0.0.1:11003",
"udp://127.0.0.1:11004",
"udp://127.0.0.1:11005",
"udp://127.0.0.1:11006",
"udp://127.0.0.1:11007",
"udp://127.0.0.1:11008",
"udp://127.0.0.1:11009",
"udp://127.0.0.1:11010",
}
t.Run("1-loop-LT", func(t *testing.T) {
testStreamProxyServer(t, addr, backendServers, false, false)
})
t.Run("1-loop-ET", func(t *testing.T) {
testStreamProxyServer(t, addr, backendServers, false, true)
})
t.Run("N-loop-LT", func(t *testing.T) {
testStreamProxyServer(t, addr, backendServers, true, false)
})
t.Run("N-loop-ET", func(t *testing.T) {
testStreamProxyServer(t, addr, backendServers, true, true)
})
})
}
func testStreamProxyServer(t *testing.T, addr string, backendServers []string, multicore, et bool) {
network, address, err := parseProtoAddr(addr)
require.NoError(t, err, "parseProtoAddr error")
srv := streamProxyServer{
tester: t,
stallCh: make(chan struct{}),
ListenerNet: network,
ListenerAddr: address,
backendServers: backendServers,
backendServerPool: backendServers,
}
var (
backends errgroup.Group
netServers []io.Closer
)
for _, backendServer := range backendServers {
network, addr, err := parseProtoAddr(backendServer)
require.NoError(t, err, "parseProtoAddr error")
if strings.HasPrefix(network, "udp") {
udpAddr, err := net.ResolveUDPAddr(network, addr)
require.NoError(t, err, "ResolveUDPAddr error")
c, err := net.ListenUDP("udp", udpAddr)
require.NoError(t, err, "ListenUDP error")
backends.Go(func() error {
startUDPEchoServer(t, c)
return nil
})
require.NoErrorf(t, err, "Start backend UDP server %s error: %v", backendServer, err)
srv.packetSize = datagramLen
netServers = append(netServers, c)
} else {
ln, err := net.Listen(network, addr)
require.NoErrorf(t, err, "Create backend server %s error: %v", network+"://"+addr, err)
backends.Go(func() error {
startStreamEchoServer(t, ln)
return nil
})
require.NoErrorf(t, err, "Start backend stream server %s error: %v", backendServer, err)
srv.packetSize = streamLen
netServers = append(netServers, ln)
}
}
// Give the backend servers some time to start.
time.Sleep(time.Second)
err = Run(&srv, addr, WithEdgeTriggeredIO(et), WithMulticore(multicore), WithTicker(true))
require.NoErrorf(t, err, "Run error: %v", err)
// Test the error handling of the methods of EventLoop after a shutdown.
_, err = srv.engine.Register(context.Background())
assert.ErrorIsf(t, err, errorx.ErrEngineInShutdown, "Expected error: %v, but got: %v",
errorx.ErrEngineInShutdown, err)
_, err = srv.eventLoop.Register(context.Background(), nil)
require.ErrorIsf(t, err, errorx.ErrEngineInShutdown, "Expected error: %v, but got: %v",
errorx.ErrEngineInShutdown, err)
_, err = srv.eventLoop.Enroll(context.Background(), nil)
require.ErrorIsf(t, err, errorx.ErrEngineInShutdown, "Expected error: %v, but got: %v",
errorx.ErrEngineInShutdown, err)
err = srv.eventLoop.Execute(context.Background(), nil)
require.ErrorIsf(t, err, errorx.ErrEngineInShutdown, "Expected error: %v, but got: %v",
errorx.ErrEngineInShutdown, err)
err = srv.eventLoop.Schedule(context.Background(), nil, time.Millisecond)
require.ErrorIsf(t, err, errorx.ErrUnsupportedOp, "Expected error: %v, but got: %v",
errorx.ErrUnsupportedOp, err)
for _, server := range netServers {
require.NoError(t, server.Close(), "Close backend server error")
}
backends.Wait() //nolint:errcheck
}
type udpProxyServer struct {
BuiltinEventEngine
packet []byte
engine Engine
tester *testing.T
stallCh chan struct{}
ListenerNet string
ListenerAddr string
activeClients int32
backendEstablished int32
backendBytes int32
initBackendPoolOnce sync.Once
backendServerPoolMu sync.Mutex
backendServerPool []Conn
startClientOnce sync.Once
backendServers []string
packetSize int
}
func (p *udpProxyServer) OnBoot(eng Engine) (action Action) {
p.engine = eng
_, err := eng.Register(context.Background())
assert.ErrorIsf(p.tester, err, errorx.ErrEmptyEngine, "Expected error: %v, but got: %v",
errorx.ErrEmptyEngine, err)
return
}
func (p *udpProxyServer) OnShutdown(Engine) {
assert.Zero(p.tester, atomic.LoadInt32(&p.backendBytes)%int32(len(p.packet)),
"backend received bytes should be a multiple of packet size")
}
func (p *udpProxyServer) OnOpen(c Conn) (out []byte, action Action) {
p.backendServerPoolMu.Lock()
p.backendServerPool = append(p.backendServerPool, c)
p.backendServerPoolMu.Unlock()
if int(atomic.AddInt32(&p.backendEstablished, 1)) == len(p.backendServers) {
// Unlock the clients to start sending data.
close(p.stallCh)
}
return nil, None
}
func (p *udpProxyServer) OnTraffic(c Conn) Action {
if c.LocalAddr().String() == p.ListenerAddr { // it's a server connection
// Echo back to the client.
buf, err := c.Next(-1)
assert.NoError(p.tester, err, "Next error")
assert.Greaterf(p.tester, len(buf), 0, "Next should not return empty buffer")
n, err := c.Write(buf)
assert.NoError(p.tester, err, "Write error")
assert.EqualValuesf(p.tester, n, len(buf), "Write should send %d bytes, but sent %d bytes", len(buf), n)
// Send the packet to a random backend server.
p.backendServerPoolMu.Lock()
backendServer := p.backendServerPool[rand.Intn(len(p.backendServerPool))]
p.backendServerPoolMu.Unlock()
err = backendServer.AsyncWrite(p.packet, nil)
assert.NoError(p.tester, err, "AsyncWrite error")
} else { // it's a backend connection
buf, err := c.Next(len(p.packet))
assert.NoError(p.tester, err, "Next error")
assert.EqualValuesf(p.tester, buf, p.packet, "Packet mismatch, expected: %s, got: %s", p.packet, buf)
atomic.AddInt32(&p.backendBytes, int32(len(buf)))
}
return None
}
func (p *udpProxyServer) OnTick() (delay time.Duration, action Action) {
p.initBackendPoolOnce.Do(func() {
for i, backendServer := range p.backendServers {
network, addr, err := parseProtoAddr(backendServer)
assert.NoError(p.tester, err, "parseProtoAddr error")
var address net.Addr
switch {
case strings.HasPrefix(network, "tcp"):
address, err = net.ResolveTCPAddr(network, addr)
case strings.HasPrefix(network, "udp"):
address, err = net.ResolveUDPAddr(network, addr)
case strings.HasPrefix(network, "unix"):
address, err = net.ResolveUnixAddr(network, addr)
default:
assert.Failf(p.tester, "unsupported protocol", "unsupported protocol: %s", network)
}
assert.NoError(p.tester, err, "ResolveNetAddr error")
// Test the error handling with empty context.
_, err = p.engine.Register(context.Background())
assert.ErrorIs(p.tester, err, errorx.ErrInvalidNetworkAddress)
var resCh <-chan RegisteredResult
if i%2 == 0 {
resCh, err = p.engine.Register(NewNetAddrContext(context.Background(), address))
} else {
c, e := net.Dial(network, addr)
assert.NoError(p.tester, e, "Dial error")
resCh, err = p.engine.Register(NewNetConnContext(context.Background(), c))
}
assert.NoError(p.tester, err, "Register connection error")
err = goPool.DefaultWorkerPool.Submit(func() {
res := <-resCh
assert.NoError(p.tester, res.Err, "Register connection error")
assert.NotNil(p.tester, res.Conn, "Register connection nil")
})
assert.NoError(p.tester, err, "Submit connection error")
}
})
p.startClientOnce.Do(func() {
for i := 0; i < len(p.backendServers); i++ {
atomic.AddInt32(&p.activeClients, 1)
err := goPool.DefaultWorkerPool.Submit(func() {
startClient(p.tester, p.ListenerNet, p.ListenerAddr,
true, false, p.packetSize, p.stallCh)
atomic.AddInt32(&p.activeClients, -1)
})
assert.NoErrorf(p.tester, err, "Submit backend server %s error: %v", p.ListenerAddr, err)
}
})
if atomic.LoadInt32(&p.activeClients) == 0 {
return 0, Shutdown
}
return time.Millisecond * 200, None
}
func TestUDPProxyServer(t *testing.T) {
t.Run("backend-udp-proxy-server", func(t *testing.T) {
addr := "udp://127.0.0.1:10000"
backendServers := []string{
"udp://127.0.0.1:10001",
"udp://127.0.0.1:10002",
"udp://127.0.0.1:10003",
"udp://127.0.0.1:10004",
"udp://127.0.0.1:10005",
"udp://127.0.0.1:10006",
"udp://127.0.0.1:10007",
"udp://127.0.0.1:10008",
"udp://127.0.0.1:10009",
"udp://127.0.0.1:10010",
}
t.Run("1-loop-LT", func(t *testing.T) {
testUDPProxyServer(t, addr, backendServers, false, false)
})
t.Run("1-loop-ET", func(t *testing.T) {
testUDPProxyServer(t, addr, backendServers, false, true)
})
t.Run("N-loop-LT", func(t *testing.T) {
testUDPProxyServer(t, addr, backendServers, true, false)
})
t.Run("N-loop-ET", func(t *testing.T) {
testUDPProxyServer(t, addr, backendServers, true, true)
})
})
t.Run("backend-tcp-proxy-server", func(t *testing.T) {
addr := "udp://127.0.0.1:20000"
backendServers := []string{
"tcp://127.0.0.1:20001",
"tcp://127.0.0.1:20002",
"tcp://127.0.0.1:20003",
"tcp://127.0.0.1:20004",
"tcp://127.0.0.1:20005",
"tcp://127.0.0.1:20006",
"tcp://127.0.0.1:20007",
"tcp://127.0.0.1:20008",
"tcp://127.0.0.1:20009",
"tcp://127.0.0.1:20010",
}
t.Run("1-loop-LT", func(t *testing.T) {
testUDPProxyServer(t, addr, backendServers, false, false)
})
t.Run("1-loop-ET", func(t *testing.T) {
testUDPProxyServer(t, addr, backendServers, false, true)
})
t.Run("N-loop-LT", func(t *testing.T) {
testUDPProxyServer(t, addr, backendServers, true, false)
})
t.Run("N-loop-ET", func(t *testing.T) {
testUDPProxyServer(t, addr, backendServers, true, true)
})
})
}
func testUDPProxyServer(t *testing.T, addr string, backendServers []string, multicore, et bool) {
network, address, err := parseProtoAddr(addr)
require.NoError(t, err, "parseProtoAddr error")
srv := udpProxyServer{
tester: t,
stallCh: make(chan struct{}),
ListenerNet: network,
ListenerAddr: address,
backendServers: backendServers,
packet: []byte("andypan"),
packetSize: datagramLen,
}
var (
backends errgroup.Group
netServers []io.Closer
)
for _, backendServer := range backendServers {
network, addr, err := parseProtoAddr(backendServer)
require.NoError(t, err, "parseProtoAddr error")
if strings.HasPrefix(network, "udp") {
udpAddr, err := net.ResolveUDPAddr(network, addr)
require.NoError(t, err, "ResolveUDPAddr error")
c, err := net.ListenUDP("udp", udpAddr)
require.NoError(t, err, "ListenUDP error")
backends.Go(func() error {
startUDPEchoServer(t, c)
return nil
})
require.NoErrorf(t, err, "Start backend UDP server %s error: %v", backendServer, err)
netServers = append(netServers, c)
} else {
ln, err := net.Listen(network, addr)
require.NoErrorf(t, err, "Create backend server %s error: %v", network+"://"+addr, err)
backends.Go(func() error {
startStreamEchoServer(t, ln)
return nil
})
require.NoErrorf(t, err, "Start backend stream server %s error: %v", backendServer, err)
netServers = append(netServers, ln)
}
}
err = Run(&srv, addr,
WithLoadBalancing(LeastConnections),
WithEdgeTriggeredIO(et),
WithMulticore(multicore),
WithTicker(true))
require.NoErrorf(t, err, "Run error: %v", err)
for _, server := range netServers {
require.NoError(t, server.Close(), "Close backend server error")
}
backends.Wait() //nolint:errcheck
}
================================================
FILE: go.mod
================================================
module github.com/panjf2000/gnet/v2
require (
github.com/panjf2000/ants/v2 v2.11.3
github.com/stretchr/testify v1.10.0
github.com/valyala/bytebufferpool v1.0.0
go.uber.org/zap v1.27.0
golang.org/x/sync v0.11.0
golang.org/x/sys v0.30.0
gopkg.in/natefinch/lumberjack.v2 v2.2.1
)
require (
github.com/davecgh/go-spew v1.1.1 // indirect
github.com/pmezard/go-difflib v1.0.0 // indirect
go.uber.org/multierr v1.11.0 // indirect
gopkg.in/yaml.v3 v3.0.1 // indirect
)
go 1.20
================================================
FILE: go.sum
================================================
github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
github.com/panjf2000/ants/v2 v2.11.3 h1:AfI0ngBoXJmYOpDh9m516vjqoUu2sLrIVgppI9TZVpg=
github.com/panjf2000/ants/v2 v2.11.3/go.mod h1:8u92CYMUc6gyvTIw8Ru7Mt7+/ESnJahz5EVtqfrilek=
github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
github.com/stretchr/testify v1.10.0 h1:Xv5erBjTwe/5IxqUQTdXv5kgmIvbHo3QQyRwhJsOfJA=
github.com/stretchr/testify v1.10.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY=
github.com/valyala/bytebufferpool v1.0.0 h1:GqA5TC/0021Y/b9FG4Oi9Mr3q7XYx6KllzawFIhcdPw=
github.com/valyala/bytebufferpool v1.0.0/go.mod h1:6bBcMArwyJ5K/AmCkWv1jt77kVWyCJ6HpOuEn7z0Csc=
go.uber.org/goleak v1.3.0 h1:2K3zAYmnTNqV73imy9J1T3WC+gmCePx2hEGkimedGto=
go.uber.org/multierr v1.11.0 h1:blXXJkSxSSfBVBlC76pxqeO+LN3aDfLQo+309xJstO0=
go.uber.org/multierr v1.11.0/go.mod h1:20+QtiLqy0Nd6FdQB9TLXag12DsQkrbs3htMFfDN80Y=
go.uber.org/zap v1.27.0 h1:aJMhYGrd5QSmlpLMr2MftRKl7t8J8PTZPA732ud/XR8=
go.uber.org/zap v1.27.0/go.mod h1:GB2qFLM7cTU87MWRP2mPIjqfIDnGu+VIO4V/SdhGo2E=
golang.org/x/sync v0.11.0 h1:GGz8+XQP4FvTTrjZPzNKTMFtSXH80RAzG+5ghFPgK9w=
golang.org/x/sync v0.11.0/go.mod h1:Czt+wKu1gCyEFDUtn0jG5QVvpJ6rzVqr5aXyt9drQfk=
golang.org/x/sys v0.30.0 h1:QjkSwP/36a20jFYWkSue1YwXzLmsV5Gfq7Eiy72C1uc=
golang.org/x/sys v0.30.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405 h1:yhCVgyC4o1eVCa2tZl7eS0r+SDo693bJlVdllGtEeKM=
gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
gopkg.in/natefinch/lumberjack.v2 v2.2.1 h1:bBRl1b0OH9s/DuPhuXpNl+VtCaJXFZ5/uEFST95x9zc=
gopkg.in/natefinch/lumberjack.v2 v2.2.1/go.mod h1:YD8tP3GAjkrDg1eZH7EGmyESg/lsYskCTPBJVb9jqSc=
gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
================================================
FILE: internal/gfd/gfd.go
================================================
// Copyright (c) 2023 The Gnet Authors. All rights reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
/*
Package gfd provides a structure GFD to store the fd, eventloop index, connStore indexes
and some other information.
GFD structure:
|eventloop index|conn matrix row index|conn matrix column index|monotone sequence| socket fd |
| 1 byte | 1 byte | 2 byte | 4 byte | 8 byte |.
*/
package gfd
import (
"encoding/binary"
"math"
"sync/atomic"
)
// Constants for GFD.
const (
ConnMatrixColumnOffset = 2
SequenceOffset = 4
FdOffset = 8
EventLoopIndexMax = math.MaxUint8 + 1
ConnMatrixRowMax = math.MaxUint8 + 1
ConnMatrixColumnMax = math.MaxUint16 + 1
)
type monotoneSeq uint32
func (seq *monotoneSeq) Inc() uint32 {
return atomic.AddUint32((*uint32)(seq), 1)
}
var monoSeq = new(monotoneSeq)
// GFD is a structure to store the fd, eventloop index, connStore indexes.
type GFD [0x10]byte
// Fd returns the underlying fd.
func (gfd GFD) Fd() int {
return int(binary.BigEndian.Uint64(gfd[FdOffset:]))
}
// EventLoopIndex returns the eventloop index.
func (gfd GFD) EventLoopIndex() int {
return int(gfd[0])
}
// ConnMatrixRow returns the connMatrix row index.
func (gfd GFD) ConnMatrixRow() int {
return int(gfd[1])
}
// ConnMatrixColumn returns the connMatrix column index.
func (gfd GFD) ConnMatrixColumn() int {
return int(binary.BigEndian.Uint16(gfd[ConnMatrixColumnOffset:SequenceOffset]))
}
// Sequence returns the monotonic sequence, only used to prevent fd duplication.
func (gfd GFD) Sequence() uint32 {
return binary.BigEndian.Uint32(gfd[SequenceOffset:FdOffset])
}
// UpdateIndexes updates the connStore indexes.
func (gfd *GFD) UpdateIndexes(row, column int) {
(*gfd)[1] = byte(row)
binary.BigEndian.PutUint16((*gfd)[ConnMatrixColumnOffset:SequenceOffset], uint16(column))
}
// Validate checks if the GFD is valid.
func (gfd GFD) Validate() bool {
return gfd.Fd() > 2 && gfd.Fd() <= math.MaxInt &&
gfd.EventLoopIndex() >= 0 && gfd.EventLoopIndex() < EventLoopIndexMax &&
gfd.ConnMatrixRow() >= 0 && gfd.ConnMatrixRow() < ConnMatrixRowMax &&
gfd.ConnMatrixColumn() >= 0 && gfd.ConnMatrixColumn() < ConnMatrixColumnMax &&
gfd.Sequence() > 0
}
// NewGFD creates a new GFD.
func NewGFD(fd, elIndex, row, column int) (gfd GFD) {
gfd[0] = byte(elIndex)
gfd[1] = byte(row)
binary.BigEndian.PutUint16(gfd[ConnMatrixColumnOffset:SequenceOffset], uint16(column))
binary.BigEndian.PutUint32(gfd[SequenceOffset:FdOffset], monoSeq.Inc())
binary.BigEndian.PutUint64(gfd[FdOffset:], uint64(fd))
return
}
================================================
FILE: listener_unix.go
================================================
// Copyright (c) 2019 The Gnet Authors. All rights reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//go:build darwin || dragonfly || freebsd || linux || netbsd || openbsd
package gnet
import (
"net"
"os"
"runtime"
"strings"
"sync"
"golang.org/x/sys/unix"
errorx "github.com/panjf2000/gnet/v2/pkg/errors"
"github.com/panjf2000/gnet/v2/pkg/logging"
"github.com/panjf2000/gnet/v2/pkg/netpoll"
"github.com/panjf2000/gnet/v2/pkg/socket"
)
type listener struct {
openOnce, closeOnce sync.Once
fd int
addr net.Addr
address, network string
sockOptInts []socket.Option[int]
sockOptStrs []socket.Option[string]
pollAttachment *netpoll.PollAttachment // listener attachment for poller
}
func (ln *listener) packPollAttachment(handler netpoll.PollEventHandler) *netpoll.PollAttachment {
ln.pollAttachment = &netpoll.PollAttachment{FD: ln.fd, Callback: handler}
return ln.pollAttachment
}
func (ln *listener) dup() (int, error) {
return socket.Dup(ln.fd)
}
func (ln *listener) open() (err error) {
ln.openOnce.Do(func() {
switch ln.network {
case "tcp", "tcp4", "tcp6":
ln.fd, ln.addr, err = socket.TCPSocket(ln.network, ln.address, true, ln.sockOptInts, ln.sockOptStrs)
ln.network = "tcp"
case "udp", "udp4", "udp6":
ln.fd, ln.addr, err = socket.UDPSocket(ln.network, ln.address, false, ln.sockOptInts, ln.sockOptStrs)
ln.network = "udp"
case "unix":
_ = os.RemoveAll(ln.address)
ln.fd, ln.addr, err = socket.UnixSocket(ln.network, ln.address, true, ln.sockOptInts, ln.sockOptStrs)
default:
err = errorx.ErrUnsupportedProtocol
}
})
return
}
func (ln *listener) close() {
ln.closeOnce.Do(func() {
if ln.fd > 0 {
logging.Error(os.NewSyscallError("close", unix.Close(ln.fd)))
}
ln.fd = -1
if ln.network == "unix" {
logging.Error(os.RemoveAll(ln.address))
}
})
}
func initListener(network, addr string, options *Options) (ln *listener, err error) {
var (
sockOptInts []socket.Option[int]
sockOptStrs []socket.Option[string]
)
if options.ReusePort && network != "unix" {
sockOpt := socket.Option[int]{SetSockOpt: socket.SetReuseport, Opt: 1}
sockOptInts = append(sockOptInts, sockOpt)
}
if options.ReuseAddr {
sockOpt := socket.Option[int]{SetSockOpt: socket.SetReuseAddr, Opt: 1}
sockOptInts = append(sockOptInts, sockOpt)
}
if options.TCPNoDelay == TCPNoDelay && strings.HasPrefix(network, "tcp") {
sockOpt := socket.Option[int]{SetSockOpt: socket.SetNoDelay, Opt: 1}
sockOptInts = append(sockOptInts, sockOpt)
}
if options.SocketRecvBuffer > 0 {
sockOpt := socket.Option[int]{SetSockOpt: socket.SetRecvBuffer, Opt: options.SocketRecvBuffer}
sockOptInts = append(sockOptInts, sockOpt)
}
if options.SocketSendBuffer > 0 {
sockOpt := socket.Option[int]{SetSockOpt: socket.SetSendBuffer, Opt: options.SocketSendBuffer}
sockOptInts = append(sockOptInts, sockOpt)
}
if strings.HasPrefix(network, "udp") {
udpAddr, err := net.ResolveUDPAddr(network, addr)
if err == nil && udpAddr.IP.IsMulticast() {
if sockoptFn := socket.SetMulticastMembership(network, udpAddr); sockoptFn != nil {
sockOpt := socket.Option[int]{SetSockOpt: sockoptFn, Opt: options.MulticastInterfaceIndex}
sockOptInts = append(sockOptInts, sockOpt)
}
}
}
if options.BindToDevice != "" {
sockOpt := socket.Option[string]{SetSockOpt: socket.SetBindToDevice, Opt: options.BindToDevice}
sockOptStrs = append(sockOptStrs, sockOpt)
}
ln = &listener{network: network, address: addr, sockOptInts: sockOptInts, sockOptStrs: sockOptStrs}
err = ln.open()
if options.TCPKeepAlive > 0 && ln.network == "tcp" &&
(runtime.GOOS == "linux" || runtime.GOOS == "freebsd" || runtime.GOOS == "dragonfly") {
// TCP keepalive options will be inherited from the listening socket
// only when running on Linux, FreeBSD, or DragonFlyBSD.
//
// Check out https://github.com/nginx/nginx/pull/337 for details.
err = setKeepAlive(
ln.fd,
true,
options.TCPKeepAlive,
options.TCPKeepInterval,
options.TCPKeepCount)
}
return
}
================================================
FILE: listener_windows.go
================================================
// Copyright (c) 2023 The Gnet Authors. All rights reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
package gnet
import (
"context"
"errors"
"net"
"os"
"sync"
"syscall"
"golang.org/x/sys/windows"
errorx "github.com/panjf2000/gnet/v2/pkg/errors"
"github.com/panjf2000/gnet/v2/pkg/logging"
)
type listener struct {
openOnce, closeOnce sync.Once
network string
address string
lc *net.ListenConfig
ln net.Listener
pc net.PacketConn
addr net.Addr
}
func (l *listener) dup() (int, error) {
if l.ln == nil && l.pc == nil {
return -1, errorx.ErrUnsupportedOp
}
var (
sc syscall.Conn
ok bool
)
if l.ln != nil {
sc, ok = l.ln.(syscall.Conn)
} else {
sc, ok = l.pc.(syscall.Conn)
}
if !ok {
return -1, errors.New("failed to convert net.Conn to syscall.Conn")
}
rc, err := sc.SyscallConn()
if err != nil {
return -1, errors.New("failed to get syscall.RawConn from net.Conn")
}
var dupHandle windows.Handle
e := rc.Control(func(fd uintptr) {
process := windows.CurrentProcess()
err = windows.DuplicateHandle(
process,
windows.Handle(fd),
process,
&dupHandle,
0,
true,
windows.DUPLICATE_SAME_ACCESS,
)
})
if err != nil {
return -1, err
}
if e != nil {
return -1, e
}
return int(dupHandle), nil
}
func (l *listener) open() (err error) {
l.openOnce.Do(func() {
switch l.network {
case "udp", "udp4", "udp6":
if l.pc, err = l.lc.ListenPacket(context.Background(), l.network, l.address); err == nil {
l.addr = l.pc.LocalAddr()
}
case "unix":
_ = os.Remove(l.address)
fallthrough
case "tcp", "tcp4", "tcp6":
if l.ln, err = l.lc.Listen(context.Background(), l.network, l.address); err == nil {
l.addr = l.ln.Addr()
}
default:
err = errorx.ErrUnsupportedProtocol
}
})
return
}
func (l *listener) close() {
l.closeOnce.Do(func() {
if l.pc != nil {
logging.Error(os.NewSyscallError("close", l.pc.Close()))
return
}
l.pc = nil
logging.Error(os.NewSyscallError("close", l.ln.Close()))
})
}
func initListener(network, addr string, options *Options) (*listener, error) {
lc := net.ListenConfig{
Control: func(network, address string, c syscall.RawConn) error {
return c.Control(func(fd uintptr) {
if network != "unix" && (options.ReuseAddr || options.ReusePort) {
_ = windows.SetsockoptInt(windows.Handle(fd), windows.SOL_SOCKET, windows.SO_REUSEADDR, 1)
}
if options.TCPNoDelay == TCPNoDelay {
_ = windows.SetsockoptInt(windows.Handle(fd), windows.IPPROTO_TCP, windows.TCP_NODELAY, 1)
}
if options.SocketRecvBuffer > 0 {
_ = windows.SetsockoptInt(windows.Handle(fd), windows.SOL_SOCKET, windows.SO_RCVBUF, options.SocketRecvBuffer)
}
if options.SocketSendBuffer > 0 {
_ = windows.SetsockoptInt(windows.Handle(fd), windows.SOL_SOCKET, windows.SO_SNDBUF, options.SocketSendBuffer)
}
})
},
KeepAlive: options.TCPKeepAlive,
}
l := listener{network: network, address: addr, lc: &lc}
return &l, l.open()
}
================================================
FILE: load_balancer.go
================================================
// Copyright (c) 2019 The Gnet Authors. All rights reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
package gnet
import (
"hash/crc32"
"net"
"github.com/panjf2000/gnet/v2/pkg/bs"
)
// LoadBalancing represents the type of load-balancing algorithm.
type LoadBalancing int
const (
// RoundRobin assigns the next accepted connection to the event-loop by polling event-loop list.
RoundRobin LoadBalancing = iota
// LeastConnections assigns the next accepted connection to the event-loop that is
// serving the least number of active connections at the current time.
LeastConnections
// SourceAddrHash assigns the next accepted connection to the event-loop by hashing the remote address.
SourceAddrHash
)
type (
// loadBalancer is an interface which manipulates the event-loop set.
loadBalancer interface {
register(*eventloop)
next(net.Addr) *eventloop
index(int) *eventloop
iterate(func(int, *eventloop) bool)
len() int
}
// baseLoadBalancer with base lb.
baseLoadBalancer struct {
eventLoops []*eventloop
size int
}
// roundRobinLoadBalancer with Round-Robin algorithm.
roundRobinLoadBalancer struct {
baseLoadBalancer
nextIndex uint64
}
// leastConnectionsLoadBalancer with Least-Connections algorithm.
leastConnectionsLoadBalancer struct {
baseLoadBalancer
}
// sourceAddrHashLoadBalancer with Hash algorithm.
sourceAddrHashLoadBalancer struct {
baseLoadBalancer
}
)
// ==================================== Implementation of base load-balancer ====================================
// register adds a new eventloop into load-balancer.
func (lb *baseLoadBalancer) register(el *eventloop) {
el.idx = lb.size
lb.eventLoops = append(lb.eventLoops, el)
lb.size++
}
// index returns the eligible eventloop by index.
func (lb *baseLoadBalancer) index(i int) *eventloop {
if i >= lb.size {
return nil
}
return lb.eventLoops[i]
}
// iterate iterates all the eventloops.
func (lb *baseLoadBalancer) iterate(f func(int, *eventloop) bool) {
for i, el := range lb.eventLoops {
if !f(i, el) {
break
}
}
}
// len returns the length of event-loop list.
func (lb *baseLoadBalancer) len() int {
return lb.size
}
// ==================================== Implementation of Round-Robin load-balancer ====================================
// next returns the eligible event-loop based on Round-Robin algorithm.
func (lb *roundRobinLoadBalancer) next(_ net.Addr) (el *eventloop) {
el = lb.eventLoops[lb.nextIndex%uint64(lb.size)]
lb.nextIndex++
return
}
// ================================= Implementation of Least-Connections load-balancer =================================
func (lb *leastConnectionsLoadBalancer) next(_ net.Addr) (el *eventloop) {
el = lb.eventLoops[0]
minN := el.countConn()
for _, v := range lb.eventLoops[1:] {
if n := v.countConn(); n < minN {
minN = n
el = v
}
}
return
}
// ======================================= Implementation of Hash load-balancer ========================================
// hash converts a string to a unique hash code.
func (*sourceAddrHashLoadBalancer) hash(s string) int {
v := int(crc32.ChecksumIEEE(bs.StringToBytes(s)))
if v >= 0 {
return v
}
return -v
}
// next returns the eligible event-loop by taking the remainder of a hash code as the index of event-loop list.
func (lb *sourceAddrHashLoadBalancer) next(netAddr net.Addr) *eventloop {
hashCode := lb.hash(netAddr.String())
return lb.eventLoops[hashCode%lb.size]
}
================================================
FILE: options.go
================================================
// Copyright (c) 2019 The Gnet Authors. All rights reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
package gnet
import (
"time"
"github.com/panjf2000/gnet/v2/pkg/logging"
)
// Option is a function that will set up option.
type Option func(opts *Options)
func loadOptions(options ...Option) *Options {
opts := new(Options)
for _, option := range options {
option(opts)
}
return opts
}
// TCPSocketOpt is the type of TCP socket options.
type TCPSocketOpt int
// Available TCP socket options.
const (
TCPNoDelay TCPSocketOpt = iota
TCPDelay
)
// Options are configurations for the gnet application.
type Options struct {
// LB represents the load-balancing algorithm used when assigning new connections
// to event loops. This option is server-only, and it is not applicable to the client.
LB LoadBalancing
// ReuseAddr indicates whether to set the SO_REUSEADDR socket option.
// This option is server-only.
ReuseAddr bool
// ReusePort indicates whether to set the SO_REUSEPORT socket option.
// This option is server-only.
ReusePort bool
// MulticastInterfaceIndex is the index of the interface name where the multicast UDP addresses will be bound to.
// This option is server-only.
MulticastInterfaceIndex int
// BindToDevice is the name of the interface to which the listening socket will be bound.
// It is only available on Linux at the moment, an error will therefore be returned when
// setting this option on non-linux platforms.
// This option is server-only.
BindToDevice string
// Multicore indicates whether the engine will be effectively created with multi-cores, if so,
// then you must take care with synchronizing memory between all event callbacks; otherwise,
// it will run the engine with single thread. The number of threads in the engine will be
// automatically assigned to the number of usable logical CPUs that can be leveraged by the
// current process.
Multicore bool
// NumEventLoop is set up to start the given number of event-loop goroutines.
// Note that a non-negative NumEventLoop will override Multicore.
NumEventLoop int
// ReadBufferCap is the maximum number of bytes that can be read from the remote when the readable event comes.
// The default value is 64KB, it can either be reduced to avoid starving the subsequent connections or increased
// to read more data from a socket.
//
// Note that ReadBufferCap will always be converted to the least power of two integer value greater than
// or equal to its real amount.
ReadBufferCap int
// WriteBufferCap is the maximum number of bytes that a static outbound buffer can hold,
// if the data exceeds this value, the overflow bytes will be stored in the elastic linked list buffer.
// The default value is 64KB.
//
// Note that WriteBufferCap will always be converted to the least power of two integer value greater than
// or equal to its real amount.
WriteBufferCap int
// LockOSThread is used to determine whether each I/O event-loop should be associated to an OS thread,
// it is useful when you need some kind of mechanisms like thread local storage, or invoke certain C
// libraries (such as graphics lib: GLib) that require thread-level manipulation via cgo, or want all I/O
// event-loops to actually run in parallel for a potential higher performance.
LockOSThread bool
// Ticker indicates whether the ticker has been set up.
Ticker bool
// TCPKeepAlive enables the TCP keep-alive mechanism (SO_KEEPALIVE) and set its value
// on TCP_KEEPIDLE.
// When TCPKeepInterval is not set, 1/5 of TCPKeepAlive will be set on TCP_KEEPINTVL,
// and 5 will be set on TCP_KEEPCNT if TCPKeepCount is not assigned to a positive value.
TCPKeepAlive time.Duration
// TCPKeepInterval is the value for TCP_KEEPINTVL, it's the interval between
// TCP keep-alive probes.
TCPKeepInterval time.Duration
// TCPKeepCount is the number of keep-alive probes that will be sent before
// the connection is considered dead and dropped.
TCPKeepCount int
// TCPNoDelay controls whether the operating system should delay
// packet transmission in hopes of sending fewer packets (Nagle's algorithm).
// When this option is assigned to TCPNoDelay, TCP_NODELAY socket option will
// be turned on, on the contrary, if it is assigned to TCPDelay, the socket
// option will be turned off.
//
// The default is TCPNoDelay, meaning that TCP_NODELAY is turned on and data
// will not be buffered but sent as soon as possible after a write operation.
TCPNoDelay TCPSocketOpt
// SocketRecvBuffer sets the maximum socket receive buffer of kernel in bytes.
SocketRecvBuffer int
// SocketSendBuffer sets the maximum socket send buffer of kernel in bytes.
SocketSendBuffer int
// LogPath specifies a local path where logs will be written, this is the easiest
// way to set up logging, gnet instantiates a default uber-go/zap logger with this
// given log path, you are also allowed to employ your own logger during the lifetime
// by implementing the following logging.Logger interface.
//
// Note that this option can be overridden by a non-nil option Logger.
LogPath string
// LogLevel specifies the logging level, it should be used along with LogPath.
LogLevel logging.Level
// Logger is the customized logger for logging info, if it is not set,
// then gnet will use the default logger powered by go.uber.org/zap.
Logger logging.Logger
// EdgeTriggeredIO enables the edge-triggered I/O for the underlying epoll/kqueue event-loop.
// Don't enable it unless you are 100% sure what you are doing.
// Note that this option is only available for stream-oriented protocol.
EdgeTriggeredIO bool
// EdgeTriggeredIOChunk specifies the number of bytes that `gnet` can
// read/write up to in one event loop of ET. This option implies
// EdgeTriggeredIO when it is set to a value greater than 0.
// If EdgeTriggeredIO is set to true and EdgeTriggeredIOChunk is not set,
// 1MB is used. The value of EdgeTriggeredIOChunk must be a power of 2,
// otherwise, it will be rounded up to the nearest power of 2.
EdgeTriggeredIOChunk int
}
// WithOptions sets up all options.
func WithOptions(options Options) Option {
return func(opts *Options) {
*opts = options
}
}
// WithMulticore enables multi-cores mode for gnet engine.
func WithMulticore(multicore bool) Option {
return func(opts *Options) {
opts.Multicore = multicore
}
}
// WithLockOSThread enables LockOSThread mode for I/O event-loops.
func WithLockOSThread(lockOSThread bool) Option {
return func(opts *Options) {
opts.LockOSThread = lockOSThread
}
}
// WithReadBufferCap sets ReadBufferCap for reading bytes.
func WithReadBufferCap(readBufferCap int) Option {
return func(opts *Options) {
opts.ReadBufferCap = readBufferCap
}
}
// WithWriteBufferCap sets WriteBufferCap for pending bytes.
func WithWriteBufferCap(writeBufferCap int) Option {
return func(opts *Options) {
opts.WriteBufferCap = writeBufferCap
}
}
// WithLoadBalancing picks the load-balancing algorithm for gnet engine.
func WithLoadBalancing(lb LoadBalancing) Option {
return func(opts *Options) {
opts.LB = lb
}
}
// WithNumEventLoop sets the number of event loops for gnet engine.
func WithNumEventLoop(numEventLoop int) Option {
return func(opts *Options) {
opts.NumEventLoop = numEventLoop
}
}
// WithReusePort sets SO_REUSEPORT socket option.
func WithReusePort(reusePort bool) Option {
return func(opts *Options) {
opts.ReusePort = reusePort
}
}
// WithReuseAddr sets SO_REUSEADDR socket option.
func WithReuseAddr(reuseAddr bool) Option {
return func(opts *Options) {
opts.ReuseAddr = reuseAddr
}
}
// WithTCPKeepAlive enables the TCP keep-alive mechanism and sets its values.
func WithTCPKeepAlive(tcpKeepAlive time.Duration) Option {
return func(opts *Options) {
opts.TCPKeepAlive = tcpKeepAlive
}
}
// WithTCPKeepInterval sets the interval between TCP keep-alive probes.
func WithTCPKeepInterval(tcpKeepInterval time.Duration) Option {
return func(opts *Options) {
opts.TCPKeepInterval = tcpKeepInterval
}
}
// WithTCPKeepCount sets the number of keep-alive probes that will be sent before
// the connection is considered dead and dropped.
func WithTCPKeepCount(tcpKeepCount int) Option {
return func(opts *Options) {
opts.TCPKeepCount = tcpKeepCount
}
}
// WithTCPNoDelay enable/disable the TCP_NODELAY socket option.
func WithTCPNoDelay(tcpNoDelay TCPSocketOpt) Option {
return func(opts *Options) {
opts.TCPNoDelay = tcpNoDelay
}
}
// WithSocketRecvBuffer sets the maximum socket receive buffer of kernel in bytes.
func WithSocketRecvBuffer(recvBuf int) Option {
return func(opts *Options) {
opts.SocketRecvBuffer = recvBuf
}
}
// WithSocketSendBuffer sets the maximum socket send buffer of kernel in bytes.
func WithSocketSendBuffer(sendBuf int) Option {
return func(opts *Options) {
opts.SocketSendBuffer = sendBuf
}
}
// WithTicker indicates whether a ticker is currently set.
func WithTicker(ticker bool) Option {
return func(opts *Options) {
opts.Ticker = ticker
}
}
// WithLogPath specifies a local path for logging file.
func WithLogPath(fileName string) Option {
return func(opts *Options) {
opts.LogPath = fileName
}
}
// WithLogLevel specifies the logging level for the local logging file.
func WithLogLevel(lvl logging.Level) Option {
return func(opts *Options) {
opts.LogLevel = lvl
}
}
// WithLogger specifies a customized logger.
func WithLogger(logger logging.Logger) Option {
return func(opts *Options) {
opts.Logger = logger
}
}
// WithMulticastInterfaceIndex sets the interface name where UDP multicast sockets will be bound to.
func WithMulticastInterfaceIndex(idx int) Option {
return func(opts *Options) {
opts.MulticastInterfaceIndex = idx
}
}
// WithBindToDevice sets the name of the interface to which the listening socket will be bound.
//
// It is only available on Linux at the moment, an error will therefore be returned when
// setting this option on non-linux platforms.
func WithBindToDevice(iface string) Option {
return func(opts *Options) {
opts.BindToDevice = iface
}
}
// WithEdgeTriggeredIO enables the edge-triggered I/O for the underlying epoll/kqueue event-loop.
func WithEdgeTriggeredIO(et bool) Option {
return func(opts *Options) {
opts.EdgeTriggeredIO = et
}
}
// WithEdgeTriggeredIOChunk sets the number of bytes that `gnet` can
// read/write up to in one event loop of ET.
func WithEdgeTriggeredIOChunk(chunk int) Option {
return func(opts *Options) {
opts.EdgeTriggeredIOChunk = chunk
}
}
================================================
FILE: os_unix_test.go
================================================
//go:build darwin || dragonfly || freebsd || linux || netbsd || openbsd
package gnet
import (
"context"
crand "crypto/rand"
"errors"
"fmt"
"math/rand"
"net"
"regexp"
"runtime"
"strings"
"sync"
"sync/atomic"
"testing"
"time"
"github.com/stretchr/testify/assert"
"golang.org/x/sys/unix"
errorx "github.com/panjf2000/gnet/v2/pkg/errors"
"github.com/panjf2000/gnet/v2/pkg/logging"
goPool "github.com/panjf2000/gnet/v2/pkg/pool/goroutine"
)
var SysClose = unix.Close
// NOTE: TestServeMulticast can fail with "write: no buffer space available" on Wi-Fi interface.
func TestServeMulticast(t *testing.T) {
t.Run("IPv4", func(t *testing.T) {
// 224.0.0.169 is an unassigned address from the Local Network Control Block
// https://www.iana.org/assignments/multicast-addresses/multicast-addresses.xhtml#multicast-addresses-1
t.Run("udp-multicast", func(t *testing.T) {
testMulticast(t, "224.0.0.169:9991", false, false, -1, 10)
})
t.Run("udp-multicast-reuseport", func(t *testing.T) {
testMulticast(t, "224.0.0.169:9991", true, false, -1, 10)
})
t.Run("udp-multicast-reuseaddr", func(t *testing.T) {
testMulticast(t, "224.0.0.169:9991", false, true, -1, 10)
})
})
t.Run("IPv6", func(t *testing.T) {
iface, err := findLoopbackInterface()
assert.NoError(t, err)
if iface.Flags&net.FlagMulticast != net.FlagMulticast {
t.Skip("multicast is not supported on loopback interface")
}
// ff02::3 is an unassigned address from Link-Local Scope Multicast Addresses
// https://www.iana.org/assignments/ipv6-multicast-addresses/ipv6-multicast-addresses.xhtml#link-local
t.Run("udp-multicast", func(t *testing.T) {
testMulticast(t, fmt.Sprintf("[ff02::3%%%s]:9991", iface.Name), false, false, iface.Index, 10)
})
t.Run("udp-multicast-reuseport", func(t *testing.T) {
testMulticast(t, fmt.Sprintf("[ff02::3%%%s]:9991", iface.Name), true, false, iface.Index, 10)
})
t.Run("udp-multicast-reuseaddr", func(t *testing.T) {
testMulticast(t, fmt.Sprintf("[ff02::3%%%s]:9991", iface.Name), false, true, iface.Index, 10)
})
})
}
func findLoopbackInterface() (*net.Interface, error) {
ifaces, err := net.Interfaces()
if err != nil {
return nil, err
}
for _, iface := range ifaces {
if iface.Flags&net.FlagLoopback == net.FlagLoopback {
return &iface, nil
}
}
return nil, errors.New("no loopback interface")
}
func testMulticast(t *testing.T, addr string, reuseport, reuseaddr bool, index, nclients int) {
ts := &testMcastServer{
t: t,
addr: addr,
nclients: nclients,
}
options := []Option{
WithReuseAddr(reuseaddr),
WithReusePort(reuseport),
WithSocketRecvBuffer(2 * nclients * 1024), // enough space to receive messages from nclients to eliminate dropped packets
WithTicker(true),
}
if index != -1 {
options = append(options, WithMulticastInterfaceIndex(index))
}
err := Run(ts, "udp://"+addr, options...)
assert.NoError(t, err)
}
type testMcastServer struct {
*BuiltinEventEngine
t *testing.T
mcast sync.Map
addr string
nclients int
started int32
active int32
}
func (s *testMcastServer) startMcastClient() {
ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
defer cancel()
c, err := net.Dial("udp", s.addr)
assert.NoError(s.t, err)
defer c.Close() //nolint:errcheck
ch := make(chan []byte, 10000)
s.mcast.Store(c.LocalAddr().String(), ch)
duration := time.Duration((rand.Float64()*2+1)*float64(time.Second)) / 2
logging.Debugf("test duration: %v", duration)
start := time.Now()
for time.Since(start) < duration {
reqData := make([]byte, 1024)
_, err = crand.Read(reqData)
assert.NoError(s.t, err)
_, err = c.Write(reqData)
assert.NoError(s.t, err)
// Workaround for MacOS "write: no buffer space available" error messages
// https://developer.apple.com/forums/thread/42334
time.Sleep(time.Millisecond * 100)
select {
case respData := <-ch:
assert.Equalf(s.t, reqData, respData, "response mismatch, length of bytes: %d vs %d", len(reqData), len(respData))
case <-ctx.Done():
assert.Fail(s.t, "timeout receiving message")
return
}
}
}
func (s *testMcastServer) OnTraffic(c Conn) (action Action) {
buf, _ := c.Next(-1)
b := make([]byte, len(buf))
copy(b, buf)
ch, ok := s.mcast.Load(c.RemoteAddr().String())
assert.True(s.t, ok)
ch.(chan []byte) <- b
return
}
func (s *testMcastServer) OnTick() (delay time.Duration, action Action) {
if atomic.CompareAndSwapInt32(&s.started, 0, 1) {
for i := 0; i < s.nclients; i++ {
atomic.AddInt32(&s.active, 1)
err := goPool.DefaultWorkerPool.Submit(func() {
defer atomic.AddInt32(&s.active, -1)
s.startMcastClient()
})
assert.NoError(s.t, err)
}
}
if atomic.LoadInt32(&s.active) == 0 {
action = Shutdown
return
}
delay = time.Second / 5
return
}
type testMulticastBindServer struct {
*BuiltinEventEngine
}
func (t *testMulticastBindServer) OnTick() (delay time.Duration, action Action) {
action = Shutdown
return
}
func TestMulticastBindIPv4(t *testing.T) {
ts := &testMulticastBindServer{}
iface, err := findLoopbackInterface()
assert.NoError(t, err)
err = Run(ts, "udp://224.0.0.169:9991",
WithMulticastInterfaceIndex(iface.Index),
WithTicker(true))
assert.NoError(t, err)
}
func TestMulticastBindIPv6(t *testing.T) {
ts := &testMulticastBindServer{}
iface, err := findLoopbackInterface()
assert.NoError(t, err)
err = Run(ts, fmt.Sprintf("udp://[ff02::3%%%s]:9991", iface.Name),
WithMulticastInterfaceIndex(iface.Index),
WithTicker(true))
assert.NoError(t, err)
}
func detectLinuxEthernetInterfaceName() (string, error) {
ifaces, err := net.Interfaces()
if err != nil {
return "", err
}
// Traditionally, network interfaces were named as eth0, eth1, etc., for Ethernet interfaces.
// However, with the introduction of predictable network interface names. Meanwhile, modern
// convention commonly uses patterns like eno[1-N], ens[1-N], enp