Fast event-loop networking for Go
eviois an event loop networking framework that is fast and small. It makes direct epoll and kqueue syscalls rather than using the standard Go net package, and works in a similar manner as libuv and libevent.
The goal of this project is to create a server framework for Go that performs on par with Redis and Haproxy for packet handling. It was built to be the foundation for Tile38 and a future L7 proxy for Go.
Please note: Evio should not be considered as a drop-in replacement for the standard Go net or net/http packages.
To start using evio, install Go and run
go get:
$ go get -u github.com/tidwall/evio
This will retrieve the library.
Starting a server is easy with
evio. Just set up your events and pass them to the
Servefunction along with the binding address(es). Each connections is represented as an
evio.Connobject that is passed to various events to differentiate the clients. At any point you can close a client or shutdown the server by return a
Closeor
Shutdownaction from an event.
Example echo server that binds to port 5000:
package mainimport "github.com/tidwall/evio"
func main() { var events evio.Events events.Data = func(c evio.Conn, in []byte) (out []byte, action evio.Action) { out = in return } if err := evio.Serve(events, "tcp://localhost:5000"); err != nil { panic(err.Error()) } }
Here the only event being used is
Data, which fires when the server receives input data from a client. The exact same input data is then passed through the output return value, which is then sent back to the client.
Connect to the echo server:
$ telnet localhost 5000
The event type has a bunch of handy events:
Servingfires when the server is ready to accept new connections.
Openedfires when a connection has opened.
Closedfires when a connection has closed.
Detachfires when a connection has been detached using the
Detachreturn action.
Datafires when the server receives new data from a connection.
Tickfires immediately after the server starts and will fire again after a specified interval.
A server can bind to multiple addresses and share the same event loop.
evio.Serve(events, "tcp://192.168.0.10:5000", "unix://socket")
The
Tickevent fires ticks at a specified interval. The first tick fires immediately after the
Servingevents.
events.Tick = func() (delay time.Duration, action Action){ log.Printf("tick") delay = time.Second return }
The
Servefunction can bind to UDP addresses.
Openedand
Closedevents are not availble for UDP sockets, only the
Dataevent.
The
events.NumLoopsoptions sets the number of loops to use for the server. A value greater than 1 will effectively make the server multithreaded for multi-core machines. Which means you must take care when synchonizing memory between event callbacks. Setting to 0 or 1 will run the server as single-threaded. Setting to -1 will automatically assign this value equal to
runtime.NumProcs().
The
events.LoadBalanceoptions sets the load balancing method. Load balancing is always a best effort to attempt to distribute the incoming connections between multiple loops. This option is only available when
events.NumLoopsis set.
Randomrequests that connections are randomly distributed.
RoundRobinrequests that connections are distributed to a loop in a round-robin fashion.
LeastConnectionsassigns the next accepted connection to the loop with the least number of active connections.
Servers can utilize the SO_REUSEPORT option which allows multiple sockets on the same host to bind to the same port.
Just provide
reuseport=trueto an address:
evio.Serve(events, "tcp://0.0.0.0:1234?reuseport=true"))
Please check out the examples subdirectory for a simplified redis clone, an echo server, and a very basic http server.
To run an example:
$ go run examples/http-server/main.go $ go run examples/redis-server/main.go $ go run examples/echo-server/main.go
These benchmarks were run on an ec2 c4.xlarge instance in single-threaded mode (GOMAXPROC=1) over Ipv4 localhost. Check out benchmarks for more info.
Josh Baker @tidwall
eviosource code is available under the MIT License.