vendor dependencies, make some changes to how input is done
This commit is contained in:
+426
@@ -0,0 +1,426 @@
|
||||
package xgb
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"errors"
|
||||
"io"
|
||||
"net"
|
||||
"regexp"
|
||||
"runtime"
|
||||
"strconv"
|
||||
"strings"
|
||||
"testing"
|
||||
"time"
|
||||
)
|
||||
|
||||
// Leaks monitor
|
||||
|
||||
type goroutine struct {
|
||||
id int
|
||||
name string
|
||||
stack []byte
|
||||
}
|
||||
|
||||
type leaks struct {
|
||||
name string
|
||||
goroutines map[int]goroutine
|
||||
report []*leaks
|
||||
}
|
||||
|
||||
func leaksMonitor(name string, monitors ...*leaks) *leaks {
|
||||
return &leaks{
|
||||
name,
|
||||
leaks{}.collectGoroutines(),
|
||||
monitors,
|
||||
}
|
||||
}
|
||||
|
||||
// ispired by https://golang.org/src/runtime/debug/stack.go?s=587:606#L21
|
||||
// stack returns a formatted stack trace of all goroutines.
|
||||
// It calls runtime.Stack with a large enough buffer to capture the entire trace.
|
||||
func (_ leaks) stack() []byte {
|
||||
buf := make([]byte, 1024)
|
||||
for {
|
||||
n := runtime.Stack(buf, true)
|
||||
if n < len(buf) {
|
||||
return buf[:n]
|
||||
}
|
||||
buf = make([]byte, 2*len(buf))
|
||||
}
|
||||
}
|
||||
|
||||
func (l leaks) collectGoroutines() map[int]goroutine {
|
||||
res := make(map[int]goroutine)
|
||||
stacks := bytes.Split(l.stack(), []byte{'\n', '\n'})
|
||||
|
||||
regexpId := regexp.MustCompile(`^\s*goroutine\s*(\d+)`)
|
||||
for _, st := range stacks {
|
||||
lines := bytes.Split(st, []byte{'\n'})
|
||||
if len(lines) < 2 {
|
||||
panic("routine stach has less tnan two lines: " + string(st))
|
||||
}
|
||||
|
||||
idMatches := regexpId.FindSubmatch(lines[0])
|
||||
if len(idMatches) < 2 {
|
||||
panic("no id found in goroutine stack's first line: " + string(lines[0]))
|
||||
}
|
||||
id, err := strconv.Atoi(string(idMatches[1]))
|
||||
if err != nil {
|
||||
panic("converting goroutine id to number error: " + err.Error())
|
||||
}
|
||||
if _, ok := res[id]; ok {
|
||||
panic("2 goroutines with same id: " + strconv.Itoa(id))
|
||||
}
|
||||
name := strings.TrimSpace(string(lines[1]))
|
||||
|
||||
//filter out our stack routine
|
||||
if strings.Contains(name, "xgb.leaks.stack") {
|
||||
continue
|
||||
}
|
||||
|
||||
res[id] = goroutine{id, name, st}
|
||||
}
|
||||
return res
|
||||
}
|
||||
|
||||
func (l leaks) leakingGoroutines() []goroutine {
|
||||
goroutines := l.collectGoroutines()
|
||||
res := []goroutine{}
|
||||
for id, gr := range goroutines {
|
||||
if _, ok := l.goroutines[id]; ok {
|
||||
continue
|
||||
}
|
||||
res = append(res, gr)
|
||||
}
|
||||
return res
|
||||
}
|
||||
func (l leaks) checkTesting(t *testing.T) {
|
||||
if len(l.leakingGoroutines()) == 0 {
|
||||
return
|
||||
}
|
||||
leakTimeout := 10 * time.Millisecond
|
||||
time.Sleep(leakTimeout)
|
||||
//t.Logf("possible goroutine leakage, waiting %v", leakTimeout)
|
||||
grs := l.leakingGoroutines()
|
||||
for _, gr := range grs {
|
||||
t.Errorf("%s: %s is leaking", l.name, gr.name)
|
||||
//t.Errorf("%s: %s is leaking\n%v", l.name, gr.name, string(gr.stack))
|
||||
}
|
||||
for _, rl := range l.report {
|
||||
rl.ignoreLeak(grs...)
|
||||
}
|
||||
}
|
||||
func (l *leaks) ignoreLeak(grs ...goroutine) {
|
||||
for _, gr := range grs {
|
||||
l.goroutines[gr.id] = gr
|
||||
}
|
||||
}
|
||||
|
||||
// dummy net.Conn
|
||||
|
||||
type dAddr struct {
|
||||
s string
|
||||
}
|
||||
|
||||
func (_ dAddr) Network() string { return "dummy" }
|
||||
func (a dAddr) String() string { return a.s }
|
||||
|
||||
var (
|
||||
dNCErrNotImplemented = errors.New("command not implemented")
|
||||
dNCErrClosed = errors.New("server closed")
|
||||
dNCErrWrite = errors.New("server write failed")
|
||||
dNCErrRead = errors.New("server read failed")
|
||||
dNCErrResponse = errors.New("server response error")
|
||||
)
|
||||
|
||||
type dNCIoResult struct {
|
||||
n int
|
||||
err error
|
||||
}
|
||||
type dNCIo struct {
|
||||
b []byte
|
||||
result chan dNCIoResult
|
||||
}
|
||||
|
||||
type dNCCWriteLock struct{}
|
||||
type dNCCWriteUnlock struct{}
|
||||
type dNCCWriteError struct{}
|
||||
type dNCCWriteSuccess struct{}
|
||||
type dNCCReadLock struct{}
|
||||
type dNCCReadUnlock struct{}
|
||||
type dNCCReadError struct{}
|
||||
type dNCCReadSuccess struct{}
|
||||
|
||||
// dummy net.Conn interface. Needs to be constructed via newDummyNetConn([...]) function.
|
||||
type dNC struct {
|
||||
reply func([]byte) []byte
|
||||
addr dAddr
|
||||
in, out chan dNCIo
|
||||
control chan interface{}
|
||||
done chan struct{}
|
||||
}
|
||||
|
||||
// Results running dummy server, satisfying net.Conn interface for test purposes.
|
||||
// 'name' parameter will be returned via (*dNC).Local/RemoteAddr().String()
|
||||
// 'reply' parameter function will be runned only on successful (*dNC).Write(b) with 'b' as parameter to 'reply'. The result will be stored in internal buffer and can be retrieved later via (*dNC).Read([...]) method.
|
||||
// It is users responsibility to stop and clean up resources with (*dNC).Close, if not needed anymore.
|
||||
// By default, the (*dNC).Write([...]) and (*dNC).Read([...]) methods are unlocked and will not result in error.
|
||||
//TODO make (*dNC).SetDeadline, (*dNC).SetReadDeadline, (*dNC).SetWriteDeadline work proprely.
|
||||
func newDummyNetConn(name string, reply func([]byte) []byte) *dNC {
|
||||
|
||||
s := &dNC{
|
||||
reply,
|
||||
dAddr{name},
|
||||
make(chan dNCIo), make(chan dNCIo),
|
||||
make(chan interface{}),
|
||||
make(chan struct{}),
|
||||
}
|
||||
|
||||
in, out := s.in, chan dNCIo(nil)
|
||||
buf := &bytes.Buffer{}
|
||||
errorRead, errorWrite := false, false
|
||||
lockRead := false
|
||||
|
||||
go func() {
|
||||
defer close(s.done)
|
||||
for {
|
||||
select {
|
||||
case dxsio := <-in:
|
||||
if errorWrite {
|
||||
dxsio.result <- dNCIoResult{0, dNCErrWrite}
|
||||
break
|
||||
}
|
||||
|
||||
response := s.reply(dxsio.b)
|
||||
|
||||
buf.Write(response)
|
||||
dxsio.result <- dNCIoResult{len(dxsio.b), nil}
|
||||
|
||||
if !lockRead && buf.Len() > 0 && out == nil {
|
||||
out = s.out
|
||||
}
|
||||
case dxsio := <-out:
|
||||
if errorRead {
|
||||
dxsio.result <- dNCIoResult{0, dNCErrRead}
|
||||
break
|
||||
}
|
||||
|
||||
n, err := buf.Read(dxsio.b)
|
||||
dxsio.result <- dNCIoResult{n, err}
|
||||
|
||||
if buf.Len() == 0 {
|
||||
out = nil
|
||||
}
|
||||
case ci := <-s.control:
|
||||
if ci == nil {
|
||||
return
|
||||
}
|
||||
switch ci.(type) {
|
||||
case dNCCWriteLock:
|
||||
in = nil
|
||||
case dNCCWriteUnlock:
|
||||
in = s.in
|
||||
case dNCCWriteError:
|
||||
errorWrite = true
|
||||
case dNCCWriteSuccess:
|
||||
errorWrite = false
|
||||
case dNCCReadLock:
|
||||
out = nil
|
||||
lockRead = true
|
||||
case dNCCReadUnlock:
|
||||
lockRead = false
|
||||
if buf.Len() > 0 && out == nil {
|
||||
out = s.out
|
||||
}
|
||||
case dNCCReadError:
|
||||
errorRead = true
|
||||
case dNCCReadSuccess:
|
||||
errorRead = false
|
||||
default:
|
||||
}
|
||||
}
|
||||
}
|
||||
}()
|
||||
return s
|
||||
}
|
||||
|
||||
// Shuts down dummy net.Conn server. Every blocking or future method calls will do nothing and result in error.
|
||||
// Result will be dNCErrClosed if server was allready closed.
|
||||
// Server can not be unclosed.
|
||||
func (s *dNC) Close() error {
|
||||
select {
|
||||
case s.control <- nil:
|
||||
<-s.done
|
||||
return nil
|
||||
case <-s.done:
|
||||
}
|
||||
return dNCErrClosed
|
||||
}
|
||||
|
||||
// Performs a write action to server.
|
||||
// If not locked by (*dNC).WriteLock, it results in error or success. If locked, this method will block until unlocked, or closed.
|
||||
//
|
||||
// This method can be set to result in error or success, via (*dNC).WriteError() or (*dNC).WriteSuccess() methods.
|
||||
//
|
||||
// If setted to result in error, the 'reply' function will NOT be called and internal buffer will NOT increasethe.
|
||||
// Result will be (0, dNCErrWrite).
|
||||
//
|
||||
// If setted to result in success, the 'reply' function will be called and its result will be writen to internal buffer.
|
||||
// If there is something in the internal buffer, the (*dNC).Read([...]) will be unblocked (if not previously locked with (*dNC).ReadLock).
|
||||
// Result will be (len(b), nil)
|
||||
//
|
||||
// If server was closed previously, result will be (0, dNCErrClosed).
|
||||
func (s *dNC) Write(b []byte) (int, error) {
|
||||
resChan := make(chan dNCIoResult)
|
||||
select {
|
||||
case s.in <- dNCIo{b, resChan}:
|
||||
res := <-resChan
|
||||
return res.n, res.err
|
||||
case <-s.done:
|
||||
}
|
||||
return 0, dNCErrClosed
|
||||
}
|
||||
|
||||
// Performs a read action from server.
|
||||
// If locked by (*dNC).ReadLock(), this method will block until unlocked with (*dNC).ReadUnlock(), or server closes.
|
||||
//
|
||||
// If not locked, this method can be setted to result imidiatly in error, will block if internal buffer is empty or will perform an read operation from internal buffer.
|
||||
//
|
||||
// If setted to result in error via (*dNC).ReadError(), the result will be (0, dNCErrWrite).
|
||||
//
|
||||
// If not locked and not setted to result in error via (*dNC).ReadSuccess(), this method will block until internall buffer is not empty, than it returns the result of the buffer read operation via (*bytes.Buffer).Read([...]).
|
||||
// If the internal buffer is empty after this method, all follwing (*dNC).Read([...]), requests will block until internall buffer is filled after successful write requests.
|
||||
//
|
||||
// If server was closed previously, result will be (0, io.EOF).
|
||||
func (s *dNC) Read(b []byte) (int, error) {
|
||||
resChan := make(chan dNCIoResult)
|
||||
select {
|
||||
case s.out <- dNCIo{b, resChan}:
|
||||
res := <-resChan
|
||||
return res.n, res.err
|
||||
case <-s.done:
|
||||
}
|
||||
return 0, io.EOF
|
||||
}
|
||||
func (s *dNC) LocalAddr() net.Addr { return s.addr }
|
||||
func (s *dNC) RemoteAddr() net.Addr { return s.addr }
|
||||
func (s *dNC) SetDeadline(t time.Time) error { return dNCErrNotImplemented }
|
||||
func (s *dNC) SetReadDeadline(t time.Time) error { return dNCErrNotImplemented }
|
||||
func (s *dNC) SetWriteDeadline(t time.Time) error { return dNCErrNotImplemented }
|
||||
|
||||
func (s *dNC) Control(i interface{}) error {
|
||||
select {
|
||||
case s.control <- i:
|
||||
return nil
|
||||
case <-s.done:
|
||||
}
|
||||
return dNCErrClosed
|
||||
}
|
||||
|
||||
// Locks writing. All write requests will be blocked until write is unlocked with (*dNC).WriteUnlock, or server closes.
|
||||
func (s *dNC) WriteLock() error {
|
||||
return s.Control(dNCCWriteLock{})
|
||||
}
|
||||
|
||||
// Unlocks writing. All blocked write requests until now will be accepted.
|
||||
func (s *dNC) WriteUnlock() error {
|
||||
return s.Control(dNCCWriteUnlock{})
|
||||
}
|
||||
|
||||
// Unlocks writing and makes (*dNC).Write to result (0, dNCErrWrite).
|
||||
func (s *dNC) WriteError() error {
|
||||
if err := s.WriteUnlock(); err != nil {
|
||||
return err
|
||||
}
|
||||
return s.Control(dNCCWriteError{})
|
||||
}
|
||||
|
||||
// Unlocks writing and makes (*dNC).Write([...]) not result in error. See (*dNC).Write for details.
|
||||
func (s *dNC) WriteSuccess() error {
|
||||
if err := s.WriteUnlock(); err != nil {
|
||||
return err
|
||||
}
|
||||
return s.Control(dNCCWriteSuccess{})
|
||||
}
|
||||
|
||||
// Locks reading. All read requests will be blocked until read is unlocked with (*dNC).ReadUnlock, or server closes.
|
||||
// (*dNC).Read([...]) wil block even after successful write.
|
||||
func (s *dNC) ReadLock() error {
|
||||
return s.Control(dNCCReadLock{})
|
||||
}
|
||||
|
||||
// Unlocks reading. If the internall buffer is not empty, next read will not block.
|
||||
func (s *dNC) ReadUnlock() error {
|
||||
return s.Control(dNCCReadUnlock{})
|
||||
}
|
||||
|
||||
// Unlocks read and makes every blocked and following (*dNC).Read([...]) imidiatly result in error. See (*dNC).Read for details.
|
||||
func (s *dNC) ReadError() error {
|
||||
if err := s.ReadUnlock(); err != nil {
|
||||
return err
|
||||
}
|
||||
return s.Control(dNCCReadError{})
|
||||
}
|
||||
|
||||
// Unlocks read and makes every blocked and following (*dNC).Read([...]) requests be handled, if according to internal buffer. See (*dNC).Read for details.
|
||||
func (s *dNC) ReadSuccess() error {
|
||||
if err := s.ReadUnlock(); err != nil {
|
||||
return err
|
||||
}
|
||||
return s.Control(dNCCReadSuccess{})
|
||||
}
|
||||
|
||||
// dummy X server replier for dummy net.Conn
|
||||
|
||||
type dXSEvent struct{}
|
||||
|
||||
func (_ dXSEvent) Bytes() []byte { return nil }
|
||||
func (_ dXSEvent) String() string { return "dummy X server event" }
|
||||
|
||||
type dXSError struct {
|
||||
seqId uint16
|
||||
}
|
||||
|
||||
func (e dXSError) SequenceId() uint16 { return e.seqId }
|
||||
func (_ dXSError) BadId() uint32 { return 0 }
|
||||
func (_ dXSError) Error() string { return "dummy X server error reply" }
|
||||
|
||||
func newDummyXServerReplier() func([]byte) []byte {
|
||||
// register xgb error & event replies
|
||||
NewErrorFuncs[255] = func(buf []byte) Error {
|
||||
return dXSError{Get16(buf[2:])}
|
||||
}
|
||||
NewEventFuncs[128&127] = func(buf []byte) Event {
|
||||
return dXSEvent{}
|
||||
}
|
||||
|
||||
// sequence number generator
|
||||
seqId := uint16(1)
|
||||
incrementSequenceId := func() {
|
||||
// this has to be the same algorithm as in (*Conn).generateSeqIds
|
||||
if seqId == uint16((1<<16)-1) {
|
||||
seqId = 0
|
||||
} else {
|
||||
seqId++
|
||||
}
|
||||
}
|
||||
return func(request []byte) []byte {
|
||||
res := make([]byte, 32)
|
||||
switch string(request) {
|
||||
case "event":
|
||||
res[0] = 128
|
||||
return res
|
||||
case "error":
|
||||
res[0] = 0 // error
|
||||
res[1] = 255 // error function
|
||||
default:
|
||||
res[0] = 1 // reply
|
||||
}
|
||||
Put16(res[2:], seqId) // sequence number
|
||||
incrementSequenceId()
|
||||
if string(request) == "noreply" {
|
||||
return nil
|
||||
}
|
||||
return res
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user