github.com/panjf2000/gnet

D:\GoWorks\pkg\mod\github.com\panjf2000\[email protected]\gnet.go:129:4: undefined: sniffError
D:\GoWorks\pkg\mod\github.com\panjf2000\[email protected]\gnet.go:159:14: too many arguments in call to serve
have (Events, []*listener, bool)
want (Events, []*listener)

https://www.techempower.com/benchmarks/ - this good start point to popularity.

我注意到，在调用React的前后，有判断action与goto进行loop循环调用，我们大家都知道，尽量避免goto调用，还有这里的action判断逻辑有点混乱不直观，让人难以理解什么时候goto

loopReact:
	out, action := lp.eventHandler.React(c)
	if out != nil {
		if frame, err := lp.codec.Encode(c, out); err == nil {
			c.write(frame)
		}
	}
	switch c.action == action {
	case true:

		goto loopReact
	case false:
		c.action = action
	}

深入阅读代码之后，发现这里的loop是为了循环调用ReadFrame()，来实现每次React只处理一帧有效数据，但是React里面还要二次判断是否为有效帧，实为浪费性能。
因此觉得优化此处代码取消goto，有以下两种方案：
Plan A: 在业务层内实现for循环遍历每一帧数据

func (hs *httpServer) React(c gnet.Conn) (out []byte, action gnet.Action) {
	for _, data := range c.ReadFrame() {
		...
	}
}

Plan B: 在React上层，for循环分好data数据

通过此样修改之后，可以取消所有关于 c.action = Skip 的判断与代码，Plan B可以收缩减少gnet暴露的接口，增加代码性能与可读性，减少React的代码量。

RT，非常容易实现，需要在Conn中有接口能获取其所属poller的index，以便在后续处理时直接使用这个index来为task queue做分片，免去计算开销

Is Websocket in the plan of gnet?

老哥，最新tag版本
好像没有暴露异步处理的接口啊。

First of all: many thanks for this library!

What is your question about gnet?
I have a question about the ring buffer: Does the ring buffer also downscaling automatically? I didn't find anything in the code, but maybe I'm blind.

I have 40k open websocket sessions, if I now reduce them to 20k, the memory consumption of the ring buffer remains on the same level, even after 30 min.

Thank you in advance for your answer.

Hi,
Do you consider about integrating gnet with f-stack or other dpdk-family net-dev lib as the second option?
Maybe the performance should be more better in some scenarios.

github.com/panjf2000/gnet

....\go\pkg\mod\github.com\panjf2000\[email protected]\gnet.go:129:4: undefined: sniffError
....\go\pkg\mod\github.com\panjf2000\[email protected]\gnet.go:159:14: too many arguments in call to serve
have (Events, []*listener, bool)
want (Events, []*listener)

Hello,

I would like to request if it is possible for lifecycle methods to be exposed to synchronously/asynchronously shutdown the listener, and to have another method/channel exposed to block the current goroutine until the listener has completed.

I'm currently doing a hack for it using the Ticker of the event loop to periodically see if an atomic integer has been set to a certain value, and if so, shut down the event loop.

2019/12/21 14:21:41 close tcp:[::]:9761->: file already closed
2019/12/21 14:21:41 close tcp [::]:9761: use of closed network connection
2019/12/21 14:21:41

UBUNTU上开启服务，然后WIN上，不断建立连接发送关闭，服务端出现上面问题，不知道如何排查，在EPOLL里面打了很多日志，但是都没显示，是不是ACCEPT这里？

Describe the bug
A clear and concise description of what the bug is.

To Reproduce
Steps to reproduce the behavior:

1. Go to '...'
2. Click on '....'
3. Scroll down to '....'
4. See error

Expected behavior
A clear and concise description of what you expected to happen.

Screenshots
If applicable, add screenshots to help explain your problem.

System Info (please complete the following information):

• OS (e.g. Ubuntu 18.04):
• Go version (e.g. Go 1.13):
• gnet version (e.g. v1.0.0):

Additional context
Add any other context about the problem here.

作为长连接服务端，gnet能否在connection级别设置timeout?即在指定时间内没有读到报文就断开连接

Describe the bug

在macbook 下使用ab测试官方给出的http例子，全部超时，浏览器可正常访问，不管是否带-k，请问你是用什么工具测试的，怎样设置超时

To Reproduce
Steps to reproduce the behavior:

1. Go to '...'
2. Click on '....'
3. Scroll down to '....'
4. See error

Expected behavior
A clear and concise description of what you expected to happen.

Screenshots
If applicable, add screenshots to help explain your problem.

System Info (please complete the following information):

• OS (e.g. Ubuntu 18.04):
• Go version (e.g. Go 1.13):
• gnet version (e.g. v1.0.0):

Additional context
Add any other context about the problem here.

It would be good have WebSocket support for this. Maybe some of the protocol code from https://github.com/gobwas/ws can be utilized for it.

作为一个小白来说看源代码有点难，，遇到了这个问题于是就来问问（反正我试了一下好像不行）。如果不能自动编码dalao有没有想法把这个加上去？

Describe the bug
gnet.Conn.RemoteAddr() returns always IPv6 for UDP.
E.g. [::7f00:1]:52815 instead of 127.0.0.1:52815

To Reproduce

func (this *Server) React(c gnet.Conn) (out []byte, action gnet.Action) {
        data := c.Read()
        log.Debugf("DATA from %v to %v: %v", c.RemoteAddr(), c.LocalAddr(), data)
        c.ResetBuffer()
        return
}

func (this *Server) listen() error {                                                                                                                                                              
        listenAddr := fmt.Sprintf("udp://%s", this.cfg.Bind)                                                                                                                                      
        err := gnet.Serve(this, listenAddr, gnet.WithMulticore(true), gnet.WithReusePort(true))
        if err != nil {                                                                                                                                                                                   return fmt.Errorf("Failed to create listening udp socket: %v", err)
        }

        return nil
}   

Expected behavior
Correct RemoteAddr

System Info (please complete the following information):

• OS (e.g. Linux): Linux
• Go Version (e.g. Go 1.13): go1.12.10 linux/amd64
• gnet Version (e.g. v1.0.0-beta.3): [email protected]

Additional context

in eventloop.go SockaddrToUDPAddr gets always called with sa6 = unix.SockaddrInet6

func (lp *loop) loopUDPIn(fd int) error {
        c := &conn{
                fd:            fd,
                localAddr:     lp.svr.ln.lnaddr,
                remoteAddr:    netpoll.SockaddrToUDPAddr(&sa6),
                inboundBuffer: lp.svr.bytesPool.Get().(*ringbuffer.RingBuffer),
        }
}

in netpoll/socktoaddr.go

func SockaddrToUDPAddr(sa unix.Sockaddr) *net.UDPAddr {
        case *unix.SockaddrInet6:
                return &net.UDPAddr{IP: ip, Port: sa.Port, Zone: zone}
        }
}

So you always get an SockaddrInet converted to SockaddrInet6 for UDP.

等待一个release

connection_windows.go

code
203 func (c *stdConn) Close() error {
204 c.loop.ch <- stderr{c, nil}
205 return nil
206 }

在Readme中给出的样例代码中，带有阻塞逻辑的部分都有一个

data := append([]byte{}, frame...)

请问这是不是意味着如果frame所带的数据如果没有被及时处理，可能会被回收或者复用覆盖？

另外如果处理的速度跟不上网络的速度，上述的这种方法似乎会导致内存占用不断上升，有没有什么办法可以限制网络的吞吐量？

see tilte, thank u.

To reproduce:

go get -u github.com/panjf2000/gnet

Result:

go: finding github.com/panjf2000/gnet v0.1.3
go: downloading github.com/panjf2000/gnet v0.1.3
go: extracting github.com/panjf2000/gnet v0.1.3
go: downloading golang.org/x/sys v0.0.0-20190412213103-97732733099d
go: downloading github.com/libp2p/go-reuseport v0.0.1
go: downloading github.com/smartystreets-prototypes/go-disruptor v0.0.0-20180723194425-e0f8f9247cc2
go: downloading github.com/gobwas/pool v0.2.0
go: extracting github.com/libp2p/go-reuseport v0.0.1
go: extracting github.com/gobwas/pool v0.2.0
go: extracting github.com/smartystreets-prototypes/go-disruptor v0.0.0-20180723194425-e0f8f9247cc2
go: extracting golang.org/x/sys v0.0.0-20190412213103-97732733099d
go: finding golang.org/x/sys latest
go: finding github.com/gobwas/pool v0.2.0
go: finding github.com/libp2p/go-reuseport v0.0.1
go: finding github.com/smartystreets-prototypes/go-disruptor latest
go: downloading golang.org/x/sys v0.0.0-20191206220618-eeba5f6aabab
go: downloading github.com/smartystreets-prototypes/go-disruptor v0.0.0-20191016010027-c1aa45f7f564
go: extracting github.com/smartystreets-prototypes/go-disruptor v0.0.0-20191016010027-c1aa45f7f564
go: extracting golang.org/x/sys v0.0.0-20191206220618-eeba5f6aabab
# github.com/panjf2000/gnet
../../../../go/pkg/mod/github.com/panjf2000/[email protected]/reactor.go:77:16: undefined: disruptor.Configure
../../../../go/pkg/mod/github.com/panjf2000/[email protected]/reactor.go:83:14: undefined: disruptor.InitialSequenceValue

感谢潘少的项目 ∩＾∩
有个疑问啊，你在文中提到如果有大量的goroutine会给go的调度带来压力，我印象中go官方提到过不会带来压力。是我理解错了吗？谢谢。

type Poller struct {
	fd            int    // epoll fd
	wfd           int    // wake fd
	wfdBuf        []byte // wfd buffer to read packet
	asyncJobQueue internal.AsyncJobQueue
}

另外能大概解析一下上面 wfd 具体作用吗？谢谢。

在处理EpollWait返回事件有以下代码，请问wfd有什么作用呢？

	if fd := int(el.events[i].Fd); fd != p.wfd { // 为什么要做这个判断呢？
		if err = callback(fd, el.events[i].Events); err != nil {
			return
		}
	} else {
		wakenUp = true
		fmt.Println("wfdbuf: ", p.wfdBuf)
		_, _ = unix.Read(p.wfd, p.wfdBuf)
	}

-------------分割线 补上

了解了eventfd的用法，对应上面的wfd，为了让异步执行的任务也统一通过epollWait来处理，但有两个疑问：
1，为什么要统一通过epollWait来统一调度呢，不可以想写数据的时候直接就往connfd中write呢？这样会有什么问题呢？谢谢。
2，

func (q *AsyncJobQueue) ForEach() (err error) {
	q.mu.Lock()
	jobs := q.jobs
	q.jobs = nil
	q.mu.Unlock()
	for i := range jobs {
		if err = jobs[i](); err != nil {
			return err
		}
	}
	return
}

ForEach 这个函数会遍历所有的jobs并执行，那么只要一个jobs写入的eventfd被调度了，那么就会执行所有的jobs，而且定时器也会定时触发这个调度。这样感觉会导致一些异步任务的执行并不是由这个任务本身去触发的，而是由其他的任务触发的，而且还会有多次write（eventfd）后，多次read（eventfd）没必要的情况（因为jobs一次就已经全部执行完了）。 请问是我哪里理解错了吗？谢谢。

Describe the bug
编译失败, 显示
C:\Users\Administrator\go\pkg\mod\github.com\panjf2000\[email protected]\gnet.go:129:4: undefined: sniffError
C:\Users\Administrator\go\pkg\mod\github.com\panjf2000\[email protected]\gnet.go:159:14: too many arguments in call to serve
have (Events, []*listener, bool)
want (Events, []*listener)

To Reproduce
Steps to reproduce the behavior:
执行的examples下的echo-server

Expected behavior
编译成功

Screenshots
If applicable, add screenshots to help explain your problem.

System Info (please complete the following information):

• OS (e.g. Ubuntu 18.04): win10
• Go version (e.g. Go 1.13): go 1.13
• gnet version (e.g. v1.0.0): v0.1.3

Additional context
Add any other context about the problem here.

你好，我实现了一个websocket服务器，客户端是异步收发信息，由于代码问题，客户端读取消息速度非常慢，发送消息很迅速。服务器每处理1个ws消息，就会回复一条十几字节的数据。
我的测试流程大概如下：
1.客户端打开一个tcp连接到gnet，预处理完毕后，连续发送1000次30字节的数据
2.服务器大概收到4次React，最后一次读取到1W字节（其实后面还有1W字节数据）
3.没有goroutine，顺序从1w字节里面一条一条消息解析，处理，并回复数据。
4.大概处理到200-300个消息的时候，整个server被阻塞，无法处理任何请求
打开pprof的goroutine查看，发现是gnet.(*conn).AsyncWrite->syscall.Syscall阻塞，代码如下

0x4ce654 syscall.Syscall+0x4 /data/server/go/src/syscall/asm_linux_amd64.s:18

0x9d3e99 golang.org/x/sys/unix.write+0x59 /mnt/e/sg_svr/src/golang.org/x/sys/unix/zsyscall_linux_amd64.go:1569

0x9d57d8 golang.org/x/sys/unix.Write+0x78 /mnt/e/sg_svr/src/golang.org/x/sys/unix/syscall_unix.go:173

0x9d579f github.com/panjf2000/gnet/netpoll.(*Poller).Trigger+0x3f /mnt/e/sg_svr/src/github.com/panjf2000/gnet/netpoll/epoll.go:58

0x9d795b github.com/panjf2000/gnet.(*conn).AsyncWrite+0x8b /mnt/e/sg_svr/src/github.com/panjf2000/gnet/connection.go:96

作为一个服务端框架如何实现推送的?

I'm trying to create a tcp protocol for my game using gnet. I put it under stress and received an incomplete message. The http example comes pretty close to my use case and does handle incomplete messages, but it's pretty complicated.

There is a large comment about the function ReadN that describes what it might be used for but not how. When should I use Read and when should I use ReadN? An example using ReadN as intended would help a great deal.

gev，gnet都很优秀，感谢你们开源付出。但是目前看你两出的基准测试结果还是有差异的，这样让使用者比较困惑，建议你两能否商量一下拿出一个统一的基准测试。

Steps to reproduce the behavior:

1. 监听tcp端口，使用多核，使用端口重用
2. 客户端打开1W个连接，并且等到1W个连接，连接成功
3. 关掉客户端
4. 服务器抛出一个nil错误，并且退出

System Info (please complete the following information):

• OS (e.g. Linux): ubuntu 19.10
• Go Version (e.g. Go 1.13): 1.13.3
• gnet Version (e.g. v1.0.0-beta.3): v1.0.0-beta7

Additional context
客户端协议使用 github.com/gorilla/websocket 实现，服务端协议轻微修改

比如 echo server，好像没有看到有测试相关代码

粘包、拆包能像netty一样提供一些内置方法使用吗？

看了代码，发现 gnet 文件名都和 eviop 差不多。。。

在对 evio 的优化时照搬了 eviop 项目中对 evio 优化时采用的 自动扩容 Ring Buffer。

Is your feature request related to a problem? Please describe.
No

Describe the solution you'd like
我看到gnet现在是通过引入第三方goroutine pool，让业务使用者自己提交耗时任务到pool，从而实现Reactors + goroutine pool，我在想能不能直接内置这个网络模型，直接把整个React方法异步化，提交到goroutine pool里执行，这样业务方就不需要自己管理耗时任务了。

Describe alternatives you've considered
A clear and concise description of any alternative solutions or features you've considered.

可不可以解答一下，搜了下没有找到方法

目前框架只封装了Server端吗？Client有无对应的封装

github.com/panjf2000/gnet v0.1.3 下载的版本，但是我比对源码好多都没有download下来，不是网络的问题，其它的都可以。

您好，根据您readme里的demo，在React里调用

_ = es.pool.Submit(func() {
	fmt.Println("Async Writing...")
	c.AsyncWrite([]byte("hello world"))
})

在client并没有及时收到数据，而是在server退出的时候才收到数据，是我使用的姿势不对吗？

RT,还有建议加个GID等工具，使用协程本地变量，自动判断是EVENTLOOP的协程还是其他协程，这样写和关闭连接可以只用一个接口。API里那些返回 action的close感觉代码业务只会太耦合
Is your feature request related to a problem? Please describe.
A clear and concise description of what the problem is. Ex. I'm always frustrated when [...]

Describe the solution you'd like
A clear and concise description of what you want to happen.

Describe alternatives you've considered
A clear and concise description of any alternative solutions or features you've considered.

Additional context
Add any other context or screenshots about the feature request here.

看到 readme 里说在 evio 基础上改的，性能优于 evio，想知道主要有哪方面的优化？最好能说明在 README 里

RT，连接频繁，导致很多连接都归到一个EPOLL下，其他EPOLL上的连接比较少

Is TLS support planned?

In accordance with tidwall/evio#28 there are no easy way to implement it:

The problem is in standard Go TLS implementation. It doesn't have an event-based idea mechanism and actually it can block calls like Reader.Read() during handshake, what is actually not accurate by the io.Reader contract.

Looks like custom TLS implementation is required for this.

Steps to reproduce the behavior:

1. 服务端监听tcp，使用多核端口复用
2. 客户端2W连接（足够多可能就会触发）
3. cpu是6核12线，发送与接收数据，客户端接收速度约5万qps
4. 数据未发送与接收完毕时，关闭客户端
   

System Info (please complete the following information):

• OS (e.g. Linux): ubuntu 19.10
• Go Version (e.g. Go 1.13): 1.13.3
• gnet Version (e.g. v1.0.0-beta.3): v1.0.0-beta.7

Additional context
附加一个建议，AsyncWrite是异步写出，导致我的写出消息[]bye，需要一直make 和 copy，我修改AsyncWrite为同步写出，不需要copy一份数据就能输出无错误，所以我需要一个直接输出消息的Write接口

Is your feature request related to a problem? Please describe.
When the gnet works with a protocols that has a connection-level configuration (like the websocket) we have a problem with the Codec abstraction.
In the websocket protocol we have a connection-level negotiation about the „extensions“ that will be applied to the connection. That means the same websocket server can handle compressed and uncompressed connections.

Describe the solution you'd like
Simple but may be hacky way to do that — have the gnet.Conn in the Encode method. When we accept a connection we can write a negotiated extensions into the conn ctx and when we make decoding — we can read it from conn.Context(). To be clear the ICodec already aware about gnet.Conn in the Decode method, why not to do that in the Encode too?

Describe alternatives you've considered
Other way might be to have a multiple codecs in the server object. And when we create the conn we should assign one of them manually (store pointer or some synthetic ID of the codec in the conn struct) into OnOpened method.

Additional context
WebSocket RFC
WebSocket permessage-deflate RFC

Is your feature request related to a problem? Please describe.
A clear and concise description of what the problem is. Ex. I'm always frustrated when [...]

Describe the solution you'd like
A clear and concise description of what you want to happen.

Describe alternatives you've considered
A clear and concise description of any alternative solutions or features you've considered.

Additional context
Add any other context or screenshots about the feature request here.

Are there any plans to implement a client library?