-
Notifications
You must be signed in to change notification settings - Fork 128
/
watcher_fsevents_cgo.go
163 lines (140 loc) · 4.37 KB
/
watcher_fsevents_cgo.go
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
// Copyright (c) 2014-2015 The Notify Authors. All rights reserved.
// Use of this source code is governed by the MIT license that can be
// found in the LICENSE file.
//go:build darwin && !kqueue && cgo
// +build darwin,!kqueue,cgo
package notify
/*
#include <CoreServices/CoreServices.h>
#include <dispatch/dispatch.h>
void gostream(uintptr_t, uintptr_t, size_t, uintptr_t, uintptr_t, uintptr_t);
static FSEventStreamRef EventStreamCreate(FSEventStreamContext * context, uintptr_t info, CFArrayRef paths, FSEventStreamEventId since, CFTimeInterval latency, FSEventStreamCreateFlags flags) {
context->info = (void*) info;
return FSEventStreamCreate(NULL, (FSEventStreamCallback) gostream, context, paths, since, latency, flags);
}
#cgo LDFLAGS: -framework CoreServices
*/
import "C"
import (
"errors"
"os"
"sync"
"sync/atomic"
"unsafe"
)
var nilstream C.FSEventStreamRef
// Default arguments for FSEventStreamCreate function.
var (
latency C.CFTimeInterval
flags = C.FSEventStreamCreateFlags(C.kFSEventStreamCreateFlagFileEvents | C.kFSEventStreamCreateFlagNoDefer)
since = uint64(C.FSEventsGetCurrentEventId())
)
// global dispatch queue which all streams are registered with
var q C.dispatch_queue_t = C.dispatch_queue_create(
C.CString("com.github.rjeczalik.notify"),
(C.dispatch_queue_attr_t)(C.DISPATCH_QUEUE_SERIAL),
)
// Errors returned when FSEvents functions fail.
var (
errCreate = os.NewSyscallError("FSEventStreamCreate", errors.New("NULL"))
errStart = os.NewSyscallError("FSEventStreamStart", errors.New("false"))
)
//export gostream
func gostream(_, info uintptr, n C.size_t, paths, flags, ids uintptr) {
const (
offchar = unsafe.Sizeof((*C.char)(nil))
offflag = unsafe.Sizeof(C.FSEventStreamEventFlags(0))
offid = unsafe.Sizeof(C.FSEventStreamEventId(0))
)
if n == 0 {
return
}
fn := streamFuncs.get(info)
if fn == nil {
return
}
ev := make([]FSEvent, 0, int(n))
for i := uintptr(0); i < uintptr(n); i++ {
switch flags := *(*uint32)(unsafe.Pointer((flags + i*offflag))); {
case flags&uint32(FSEventsEventIdsWrapped) != 0:
atomic.StoreUint64(&since, uint64(C.FSEventsGetCurrentEventId()))
default:
ev = append(ev, FSEvent{
Path: C.GoString(*(**C.char)(unsafe.Pointer(paths + i*offchar))),
Flags: flags,
ID: *(*uint64)(unsafe.Pointer(ids + i*offid)),
})
}
}
fn(ev)
}
// StreamFunc is a callback called when stream receives file events.
type streamFunc func([]FSEvent)
var streamFuncs = streamFuncRegistry{m: map[uintptr]streamFunc{}}
type streamFuncRegistry struct {
mu sync.Mutex
m map[uintptr]streamFunc
i uintptr
}
func (r *streamFuncRegistry) get(id uintptr) streamFunc {
r.mu.Lock()
defer r.mu.Unlock()
return r.m[id]
}
func (r *streamFuncRegistry) add(fn streamFunc) uintptr {
r.mu.Lock()
defer r.mu.Unlock()
r.i++
r.m[r.i] = fn
return r.i
}
func (r *streamFuncRegistry) delete(id uintptr) {
r.mu.Lock()
defer r.mu.Unlock()
delete(r.m, id)
}
// Stream represents a single watch-point which listens for events scheduled on the global dispatch queue.
type stream struct {
path string
ref C.FSEventStreamRef
info uintptr
}
// NewStream creates a stream for given path, listening for file events and
// calling fn upon receiving any.
func newStream(path string, fn streamFunc) *stream {
return &stream{
path: path,
info: streamFuncs.add(fn),
}
}
// Start creates a FSEventStream for the given path and schedules on the global dispatch queue.
// It's a nop if the stream was already started.
func (s *stream) Start() error {
if s.ref != nilstream {
return nil
}
p := C.CFStringCreateWithCStringNoCopy(C.kCFAllocatorDefault, C.CString(s.path), C.kCFStringEncodingUTF8, C.kCFAllocatorDefault)
path := C.CFArrayCreate(C.kCFAllocatorDefault, (*unsafe.Pointer)(unsafe.Pointer(&p)), 1, nil)
ctx := C.FSEventStreamContext{}
ref := C.EventStreamCreate(&ctx, C.uintptr_t(s.info), path, C.FSEventStreamEventId(atomic.LoadUint64(&since)), latency, flags)
if ref == nilstream {
return errCreate
}
C.FSEventStreamSetDispatchQueue(ref, q)
if C.FSEventStreamStart(ref) == C.Boolean(0) {
C.FSEventStreamInvalidate(ref)
return errStart
}
s.ref = ref
return nil
}
// Stop stops underlying FSEventStream and unregisters it from the global dispatch queue.
func (s *stream) Stop() {
if s.ref == nilstream {
return
}
C.FSEventStreamStop(s.ref)
C.FSEventStreamInvalidate(s.ref)
s.ref = nilstream
streamFuncs.delete(s.info)
}