mmio

mmio

High performance async network io library

First

if you have any good feature suggestions or bug fixed , any Pull Request or Issues are welcome!

Usage

# install mmio 
go get -u github.com/ooopSnake/mmio@latest

// import 
import "github.com/ooopSnake/mmio"

Overview

• World Based On Event Loop 😎
• UnBuffered/Buffered Stream 🚀
• Timers: IO Timeout, Delay... ⏰
• DNS Resolve 🌐
• Lots Of Unix Socket API Toolbox 🔧
• Thread(Goroutine) Safe! 👍

Backend

mmio using interface Poller and Watcher as abstraction for any backend.

Getting Started

Create Pure EventLoop:

loop,err := mmio.NewEventLoop()
merrors.AssertError(err, "new pure event loop")

Create IO EventLoop:

loop, err := mmio.NewIOEvtLoop(1024 * 4)
merrors.AssertError(err, "new io event loop")

Loop Lifecycle:

exit a loop

// just call loop.Break in anywhere
loop.Break()

📌Loop.'Close' can't stop a loop but Loop.'Break' can.

📌Loop.'Close' use to cleanup a loop

Cleanup a loop

loop ,err := mmio.NewEventLoop()
merrors.AssertError(err, "new event loop")
defer loop.Close()

Run loop synchronously

// block until break loop called
loop.Run()

Run loop asynchronously😂😂😂

go func(){ loop.Run() }()

Create Listener:

// create listen fd first!
listenerFd, err := mmio.NewListenerFd(
  "127.0.0.1:12345", // serve at
  1024,              // backlog
  true,              // enable reuse addr
  true,              // enable reuse port
)
merrors.AssertError(err, "new listener fd")
// new listener
listener := mmio.NewListener(loop, int(listenerFd), onAccept)
listener.Start()

Accept New Conn Stream:

// 📌Note: in accept callback
stream := mmio.NewConnStream(
  ln.Loop().(*mmio.IOEvtLoop), // cast Loop to IOEventLoop 
  newFd,                         // incoming fd
  onStreamRead,                  // read callback
  )
stream.SetOnClose(onStreamClose) // register close callback
stream.Start()

Create Client Stream:

cliFd, err := mmio.NewConnFd(addr)
merrors.AssertError(err, "new client fd failed")
stream := mmio.NewConnStream(loop, int(cliFd), nil)
stream.SetOnConnect(func(sw mmio.StreamWriter, err error) {
  sw.Write([]byte("hello world!"), true)
})
stream.SetOnClose(func(sw mmio.StreamWriter, err error) {
  log.Println("client close :", err)
  // break loop...
  loop.Break()
})
stream.Start()

📌Stream.'Close' is safe to invoke multi times

📌Anytime you can't find out whether if Stream is 'Closing' or really been 'Closed',Just invoke Stream.'Close'

Example: Simple Read/Write/Close

package main

import (
	"github.com/guestin/mob/merrors"
	"github.com/guestin/mob/mio"
	"github.com/ooopSnake/mmio"
	"log"
)

func onRemoteStreamRead(sw mmio.StreamWriter, data []byte, len int) {
	log.Println("read remote conn:", string(data[:len]))
	_ = sw.Close()
}

func onRemoteStreamClose(sw mmio.StreamWriter, err error) {
	log.Println("remote conn closed,err:", err)
	// it's safe to call Close multi times
	_ = sw.Close() // close remote client
}

func onAccept(ln *mmio.Listener, newFd int, err error) {
	if err != nil {
		log.Printf("listener got error:%v\n", err)
		return
	}
	stream := mmio.NewConnStream(ln.Loop().(*mmio.IOEvtLoop), newFd, onRemoteStreamRead)
	stream.SetOnClose(onRemoteStreamClose)
	stream.Start()
}

func simpleClient(loop *mmio.IOEvtLoop, addr string) {
	cliFd, err := mmio.NewConnFd(addr)
	merrors.AssertError(err, "new client fd failed")
	stream := mmio.NewConnStream(loop, int(cliFd), nil)
	stream.SetOnConnect(func(sw mmio.StreamWriter, err error) {
		sw.Write([]byte("hello world!"), true)
	})
	stream.SetOnClose(func(sw mmio.StreamWriter, err error) {
		log.Println("client close :", err)
		_ = sw.Close() // dont forgot close stream itself
		// break loop...
		loop.Break()
	})
	stream.Start()
}

func main() {
	log.Println("simple listener start...")
	loop, err := mmio.NewIOEvtLoop(1024 * 4)
	merrors.AssertError(err, "new event loop")
	defer mio.CloseIgnoreErr(loop)
	// create listen fd first!
	listenerFd, err := mmio.NewListenerFd(
		"127.0.0.1:12345", // serve at
		1024,              // backlog
		true,              // enable reuse addr
		true,              // enable reuse port
	)
	merrors.AssertError(err, "new listener fd")
	// new listener
	listener := mmio.NewListener(loop, int(listenerFd), onAccept)
	defer mio.CloseIgnoreErr(listener)
	listener.Start()
	// start simple client
	simpleClient(loop, "127.0.0.1:12345")
	//
	loop.Run(nil)
	log.Println("simple listener exit...")
}

License

Released under the MIT License