kqueue.go

package main

import (
	"time"
	"net"
	"os"
	"strings"
	"fmt"
	"syscall"
)


func AddRead(p, fd int, readon, writeon *bool) error {
	if readon != nil {
		if *readon {
			return nil
		}
		*readon = true
	}
	_, err := syscall.Kevent(p,
		[]syscall.Kevent_t{{Ident: uint64(fd),
			Flags: syscall.EV_ADD, Filter: syscall.EVFILT_READ}},
		nil, nil)
	return err
}
func DelRead(p, fd int, readon, writeon *bool) error {
	if readon != nil {
		if !*readon {
			return nil
		}
		*readon = false
	}
	_, err := syscall.Kevent(p,
		[]syscall.Kevent_t{{Ident: uint64(fd),
			Flags: syscall.EV_DELETE, Filter: syscall.EVFILT_READ}},
		nil, nil)
	return err
}

func AddWrite(p, fd int, readon, writeon *bool) error {
	if writeon != nil {
		if *writeon {
			return nil
		}
		*writeon = true
	}
	_, err := syscall.Kevent(p,
		[]syscall.Kevent_t{{Ident: uint64(fd),
			Flags: syscall.EV_ADD, Filter: syscall.EVFILT_WRITE}},
		nil, nil)
	return err
}
func DelWrite(p, fd int, readon, writeon *bool) error {
	if writeon != nil {
		if !*writeon {
			return nil
		}
		*writeon = false
	}
	_, err := syscall.Kevent(p,
		[]syscall.Kevent_t{{Ident: uint64(fd),
			Flags: syscall.EV_DELETE, Filter: syscall.EVFILT_WRITE}},
		nil, nil)
	return err
}

func MakePoll() (p int, err error) {
	return syscall.Kqueue()
}
func MakeEvents(n int) interface{} {
	return make([]syscall.Kevent_t, n)
}
func Wait(p int, evs interface{}, timeout time.Duration) (n int, err error) {
	if timeout < 0 {
		timeout = 0
	}
	ts := syscall.NsecToTimespec(int64(timeout))
	return syscall.Kevent(p, nil, evs.([]syscall.Kevent_t), &ts)
}
func GetFD(evs interface{}, i int) int {
	return int(evs.([]syscall.Kevent_t)[i].Ident)
}
/*

 */

type Action int

type Events struct {
	Serving func(server Server) (action Action)
}

type listener struct {
	ln      net.Listener
	lnaddr  net.Addr
	pconn   net.PacketConn
	f       *os.File
	fd      int
	network string
	addr    string
}

type Server struct {
	Addrs []net.Addr
	Wake func(id int) (ok bool)
	Dial func(addr string,timeout time.Duration) (id int)
}

func parseAddr(addr string) (network, address string, stdlib bool) {
	network = "tcp"
	address = addr
	if strings.Contains(address, "://") {
		network = strings.Split(address, "://")[0]
		address = strings.Split(address, "://")[1]
	}
	if strings.HasSuffix(network, "-net") {
		stdlib = true
		network = network[:len(network)-4]
	}
	return
}

func Serve(events Events,addr ...string) error {
	var lns []*listener

	var stdlib bool
	for _, addr := range addr {
		var ln listener
		var stdlibt bool

		ln.network, ln.addr, stdlibt = parseAddr(addr)

		if stdlibt {
			stdlib = true
		}
		if ln.network == "unix" {
			os.RemoveAll(ln.addr)
		}

		var err error
		if ln.network == "udp" {
			ln.pconn, err = net.ListenPacket(ln.network, ln.addr)
		} else {
			ln.ln, err = net.Listen(ln.network, ln.addr)
		}

		if err != nil {
			return err
		}

		lns = append(lns, &ln)

		fmt.Print(stdlib)
	}

	p, _ := MakePoll()

	fmt.Println("casdaddsassdasa")
	fmt.Println(p)

	return nil
}

func main() {
	var events Events

	err := Serve(events,"tcp://localhost:5000")
	fmt.Println(err)

	time.Sleep(300000000000000)
}