func newpollster() (p *pollster, err error) {
p = new(pollster)
var e int
if p.kq, e = syscall.Kqueue(); e != 0 {
return nil, os.NewSyscallError("kqueue", e)
}
p.events = p.eventbuf[0:0]
return p, nil
}
// kqueue creates a new kernel event queue and returns a descriptor.
func kqueue() (kq int, err error) {
kq, err = syscall.Kqueue()
if kq == -1 {
return kq, err
}
return kq, nil
}
func runKqueue() {
fd, err := syscall.Kqueue()
evTrackList := make([]syscall.Kevent_t, 1024)
if err != nil {
log.Fatal("error initializing Kqueue: ", err)
return
}
addFilesToKqueue(evTrackList, path)
// configure timeout
timeout := syscall.Timespec{
Sec: 0,
Nsec: 0,
}
// wait for events
for {
// create kevent
events := make([]syscall.Kevent_t, 10)
_, err := syscall.Kevent(fd, evTrackList, events, &timeout)
if err != nil {
log.Println("Error creating kevent")
}
// check if there was an event and process it
if len(events) > 0 && events[0].Ident > 0 {
processEvent()
}
}
}
func NewPoll() (p *pollster, err error) {
p = new(pollster)
if p.kq, err = syscall.Kqueue(); err != nil {
return nil, os.NewSyscallError("kqueue", err)
}
syscall.CloseOnExec(p.kq)
return p, nil
}
func newpollster() (p *pollster, err error) {
p = new(pollster)
if p.kq, err = syscall.Kqueue(); err != nil {
return nil, os.NewSyscallError("kqueue", err)
}
syscall.CloseOnExec(p.kq)
p.events = p.eventbuf[0:0]
return p, nil
}
func NewKqueue() (*Kqueue, error) {
fd, err := syscall.Kqueue()
if err != nil {
return nil, os.NewSyscallError("kqueue", err)
}
return &Kqueue{
Fd: fd,
}, nil
}
func newkqueue() (*kqueue, error) {
fd, err := syscall.Kqueue()
if err != nil {
return nil, os.NewSyscallError("kqueue", err)
}
return &kqueue{
fd: fd,
}, nil
}
func NewWatcher() (IFSEventsWatcher, error) {
if fd, err := syscall.Kqueue(); fd == sysCallFailed {
return nil, os.NewSyscallError("kqueue", err)
} else {
w := &watcher{
kq: fd,
watchedByFD: make(map[int]*watchInfo),
watchedByPath: make(map[string]*watchInfo),
}
return w, nil
}
}
// init initializes kqueue.
func (k *kqueue) init() (err error) {
if k.fd, err = syscall.Kqueue(); err != nil {
return
}
// Creates pipe used to stop `Kevent` call by registering it,
// watching read end and writing to other end of it.
if err = syscall.Pipe(k.pipefds[:]); err != nil {
return
}
var kevn [1]syscall.Kevent_t
syscall.SetKevent(&kevn[0], k.pipefds[0], syscall.EVFILT_READ, syscall.EV_ADD)
_, err = syscall.Kevent(k.fd, kevn[:], nil, nil)
return
}
func New(fd int) (p *Poller, err error) {
p = &Poller{}
p.kqfd, err = syscall.Kqueue()
if p.kqfd == -1 || err != nil {
return nil, err
}
p.event = syscall.Kevent_t{
Ident: uint32(fd),
Filter: syscall.EVFILT_WRITE,
Flags: syscall.EV_ADD | syscall.EV_ENABLE | syscall.EV_ONESHOT,
Fflags: 0,
Data: 0,
Udata: nil,
}
return p, nil
}
// NewWatcher creates and returns a new kevent instance using kqueue(2)
func NewWatcher() (*Watcher, error) {
fd, errno := syscall.Kqueue()
if fd == -1 {
return nil, os.NewSyscallError("kqueue", errno)
}
w := &Watcher{
kq: fd,
watches: make(map[string]int),
paths: make(map[int]string),
finfo: make(map[int]*os.FileInfo),
Event: make(chan *FileEvent),
Error: make(chan error),
done: make(chan bool, 1),
}
go w.readEvents()
return w, nil
}
// NewWatcher creates and returns a new kevent instance using kqueue(2)
func NewWatcher() (*Watcher, error) {
fd, errno := syscall.Kqueue()
if fd == -1 {
return nil, os.NewSyscallError("kqueue", errno)
}
w := &Watcher{
kq: fd,
watches: make(map[string]int),
enFlags: make(map[string]uint32),
paths: make(map[int]string),
finfo: make(map[int]os.FileInfo),
fileExists: make(map[string]bool),
externalWatches: make(map[string]bool),
Events: make(chan Event),
Errors: make(chan error),
done: make(chan bool, 1),
}
go w.readEvents()
return w, nil
}
func main() {
flag.Parse()
args = flag.Args()
var err error
win, err = acme.New()
if err != nil {
log.Fatal(err)
}
pwd, _ := os.Getwd()
win.Name(pwd + "/+watch")
win.Ctl("clean")
win.Fprintf("tag", "Get ")
needrun <- true
go events()
go runner()
kq.fd, err = syscall.Kqueue()
if err != nil {
log.Fatal(err)
}
kq.m = make(map[string]*os.File)
kq.name = make(map[int]string)
dir, err := os.Open(".")
if err != nil {
log.Fatal(err)
}
kq.dir = dir
kadd(int(dir.Fd()))
readdir := true
for {
if readdir {
kq.dir.Seek(0, 0)
names, err := kq.dir.Readdirnames(-1)
if err != nil {
log.Fatalf("readdir: %v", err)
}
for _, name := range names {
if kq.m[name] != nil {
continue
}
f, err := os.Open(name)
if err != nil {
continue
}
kq.m[name] = f
fd := int(f.Fd())
kq.name[fd] = name
kadd(fd)
}
}
kbuf := make([]syscall.Kevent_t, 1)
var n int
for {
n, err = syscall.Kevent(kq.fd, nil, kbuf[:1], nil)
if err == syscall.EINTR {
continue
}
break
}
if err != nil {
log.Fatalf("kevent wait: %v", err)
}
ev := &kbuf[0]
if n != 1 || int(ev.Filter) != syscall.EVFILT_VNODE {
log.Fatal("kqueue phase error")
}
select {
case needrun <- true:
default:
}
fd := int(ev.Ident)
readdir = fd == int(kq.dir.Fd())
time.Sleep(100 * time.Millisecond)
kadd(fd)
}
}
// Initialize bsd implementation of the eventListener interface
func createListener() (eventListener, error) {
listener := &kqueueListener{}
kq, err := syscall.Kqueue()
listener.kq = kq
return listener, err
}