// closeOrErr calls cl.Close() and sets err to the returned error value if
// itself is not yet set.
func closeOrErr(cl io.Closer, err *error) {
e := cl.Close()
if *err != nil {
return
}
*err = e
}
func logclose(c io.Closer) error {
err := c.Close()
if err != nil {
logf("Error closing %T: %v", c, err)
}
return err
}
func TestLockInChild(t *testing.T) {
f := os.Getenv("TEST_LOCK_FILE")
if f == "" {
// not child
return
}
lock := Lock
if v, _ := strconv.ParseBool(os.Getenv("TEST_LOCK_PORTABLE")); v {
lock = lockPortable
}
var lk io.Closer
for scan := bufio.NewScanner(os.Stdin); scan.Scan(); {
var err error
switch scan.Text() {
case "lock":
lk, err = lock(f)
case "unlock":
err = lk.Close()
lk = nil
case "exit":
// Simulate a crash, or at least not unlocking the lock.
os.Exit(0)
default:
err = fmt.Errorf("unexpected child command %q", scan.Text())
}
if err != nil {
fmt.Println(err)
} else {
fmt.Println("")
}
}
}
func (p *Pool) Put(c io.Closer) {
select {
case p.connch <- c:
default:
c.Close()
}
}
func stdinWatcher(cmd *exec.Cmd, childStdin io.Closer, graceful bool) {
b := make([]byte, 1)
for {
_, err := os.Stdin.Read(b)
if err != nil {
log.Printf("got %s when reading stdin; terminating.", err.Error())
break
}
if b[0] == '\n' || b[0] == '\r' {
log.Printf("got new line on a stdin; terminating.")
break
}
}
if graceful {
err := childStdin.Close()
if err != nil {
log.Fatalf("failed to close child's stdin: %s", err.Error())
}
} else {
err := cmd.Process.Kill()
if err != nil {
log.Fatalf("failed to kill the child: %s", err.Error())
}
os.Exit(0)
}
}
func (c *contextGroup) AddChild(child io.Closer) {
c.children.Add(1)
go func(parent ContextGroup, child io.Closer) {
<-parent.Closing() // wait until parent is closing
child.Close() // signal child to close
parent.Children().Done() // child signals it is done
}(c, child)
}
func checkClose(c io.Closer, err error) {
if c != nil {
cerr := c.Close()
if err == nil {
err = cerr
}
}
}
func safeClose(obj io.Closer) (err error) {
defer func() {
if p := recover(); p != nil {
err = errors.New(fmt.Sprintf("%v", p))
}
}()
return obj.Close()
}
//DoBroker provides the internal copy operation
func DoBroker(dest io.WriteCloser, src io.ReadCloser, end io.Closer, err NotifierError) {
_, ex := io.Copy(dest, src)
if ex != nil {
go func() { err <- ex }()
}
end.Close()
}
func closeAndExit(db io.Closer, code int, message ...interface{}) {
for _, m := range message {
fmt.Fprintln(os.Stderr, m)
}
if err := db.Close(); err != nil {
fmt.Fprintf(os.Stderr, "db.Close() error: %s\n", err)
}
os.Exit(code)
}
func (cli *DockerCli) restoreTerminal(in io.Closer) error {
if cli.state != nil {
term.RestoreTerminal(cli.inFd, cli.state)
}
if in != nil {
return in.Close()
}
return nil
}
func f1() {
// The 5 here and below depends on the number of internal runtime frames
// that sit between a deferred function called during panic and
// the original frame. If that changes, this test will start failing and
// the number here will need to be updated.
defer checkLine(5)
var t *T
var c io.Closer = t
c.Close()
}
// setClosed sets the close flag and returns the previous status.
func (s *Sniffer) setClosed(conn io.Closer) bool {
s.lock.Lock()
defer s.lock.Unlock()
old := s.closed
s.closed = true
if !old && conn != nil {
conn.Close()
}
return old
}
func loggedClose(c io.Closer, name string) {
err := c.Close()
if err != nil {
if name != "" {
glog.Warningf("error closing %s: %v", name, err)
} else {
glog.Warningf("error closing %v: %v", c, err)
}
}
}
func (p ping) wait(duration time.Duration, done io.Closer) {
defer done.Close()
for {
select {
case <-p:
case <-time.After(duration):
return
}
}
}
func ensureEOFOnClose(t *testing.T, r io.Reader, w io.Closer) {
b := make([]byte, 10)
w.Close()
n, err := r.Read(b)
if n > 0 {
t.Errorf("unexpected byte count %d", n)
}
if err != io.EOF {
t.Errorf("expected EOF: %v", err)
}
}
func (this *ConnPool) Release(conn io.Closer) {
if this.overMaxIdle() {
this.decreActive()
if conn != nil {
conn.Close()
}
} else {
this.Lock()
defer this.Unlock()
this.free = append(this.free, conn)
}
}
func closeOnTerm(c io.Closer) {
ch := make(chan os.Signal, 1)
signal.Notify(ch, os.Interrupt, syscall.SIGTERM)
go func() {
<-ch
log.Printf("shutting down...")
if err := c.Close(); err != nil {
log.Fatalf("clean up error: %v", err)
}
os.Exit(1)
}()
}
func restoreTerminal(streams streams, in io.Closer) error {
streams.In().RestoreTerminal()
streams.Out().RestoreTerminal()
// WARNING: DO NOT REMOVE THE OS CHECK !!!
// For some reason this Close call blocks on darwin..
// As the client exists right after, simply discard the close
// until we find a better solution.
if in != nil && runtime.GOOS != "darwin" {
return in.Close()
}
return nil
}
func (p *ConnPool) CloseClean(conn io.Closer) error {
if conn != nil {
conn.Close()
}
p.Lock()
if p.conns > 0 {
p.conns -= 1
}
logger.Trace("%s close_clean conn: %v, pool: %+v", LOG_TAG, conn, p)
p.Unlock()
return nil
}
func close_both(closer1, closer2 io.Closer) {
var wg sync.WaitGroup
wg.Add(2)
go func() {
defer wg.Done()
closer1.Close()
}()
go func() {
defer wg.Done()
closer2.Close()
}()
wg.Wait()
}
func (cli *DockerCli) restoreTerminal(in io.Closer) error {
if cli.state != nil {
term.RestoreTerminal(cli.inFd, cli.state)
}
// WARNING: DO NOT REMOVE THE OS CHECK !!!
// For some reason this Close call blocks on darwin..
// As the client exists right after, simply discard the close
// until we find a better solution.
if in != nil && runtime.GOOS != "darwin" {
return in.Close()
}
return nil
}
func testAutogeneratedFunction() {
defer func() {
if err := recover(); err == nil {
panic("did not panic")
}
CallerInfo()
}()
t := struct {
io.Closer
}{}
var c io.Closer
c = t
c.Close()
}
func timeoutRead(body io.Closer, read func()) (ok bool) {
done := make(chan struct{})
go func() {
read()
done <- struct{}{}
}()
select {
case <-done:
return true
case <-time.After(timeout):
body.Close()
return false
}
}
func TrapCloser(cl io.Closer, cleanups ...Cleanup) {
c := make(chan os.Signal, 1)
signal.Notify(c, syscall.SIGINT, syscall.SIGKILL, syscall.SIGTERM, syscall.SIGHUP)
go func() {
for {
rawSig := <-c
sig, ok := rawSig.(syscall.Signal)
if !ok {
log.Fatal("not a unix signal")
}
switch {
case sig == syscall.SIGHUP:
log.Print("SIGHUP: restart process")
err := RestartProcess()
if err != nil {
log.Fatal("failed to restart: " + err.Error())
}
case sig == syscall.SIGINT || sig == syscall.SIGKILL || sig == syscall.SIGTERM:
log.Print("shutting down")
donec := make(chan bool)
go func() {
for _, cb := range cleanups {
if err := cb(); err != nil {
log.Error(err)
}
}
if err := cl.Close(); err != nil {
log.Fatalf("Error shutting down: %v", err)
}
donec <- true
}()
select {
case <-donec:
log.Printf("shutdown")
os.Exit(0)
case <-time.After(5 * time.Second):
log.Fatal("Timeout shutting down. Exiting uncleanly.")
}
default:
log.Fatal("Received another signal, should not happen.")
}
}
}()
}
func fxImageProviderIoReader(arg interface{}) (img image.Image, err error) {
var (
ok bool
closer io.Closer
reader io.Reader
)
if closer, ok = arg.(io.Closer); ok {
defer closer.Close()
}
if reader, ok = arg.(io.Reader); ok {
img, _, err = image.Decode(reader)
}
return
}
func baseServerStop(baseServer *baseServer, closer io.Closer) {
baseServer.statusLock.Lock()
baseServer.serverStatus = stopped
baseServer.statusLock.Unlock()
// send quit to close channel
quit := make(chan struct{})
baseServer.stopCh <- quit
closer.Close()
// wait
<-quit
}
func (t T) close(c io.Closer) {
if c != nil {
if db, _ := c.(*Conn); db != nil {
if path := db.Path("main"); path != "" {
defer os.Remove(path)
}
}
if err := c.Close(); err != nil {
if !t.Failed() {
t.Fatalf(cl("(%T).Close() unexpected error: %v"), c, err)
}
t.FailNow()
}
}
}
func (h *FileWritingHandler) handleConn(index int, suffix string, r io.Reader, c io.Closer) {
defer c.Close()
out, err := h.FileCreater.Create(index, suffix)
if err != nil {
log.Printf("Error creating file: %v", err)
return
}
defer out.Close()
_, err = io.Copy(out, r)
if err != nil {
log.Printf("Error copying to file: %v", err)
}
}
func (p *ConnPool) Release(conn io.Closer) error {
p.Lock()
if len(p.free) >= p.MaxIdle {
logger.Trace("%s auto close conn: %v, pool: %+v", LOG_TAG, conn, p)
if conn != nil {
conn.Close()
}
p.conns -= 1
} else {
p.free = append(p.free, conn)
}
logger.Trace("%s release conn: %v, pool: %+v", LOG_TAG, conn, p)
p.Unlock()
return nil
}
