code review 4550112: http: don't fail on accept hitting EMFILE

src/pkg/http/server.go

 // Copyright 2009 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
 // HTTP server.  See RFC 2616.
 
 // TODO(rsc):
 //      logging
 
 package http
 
 import (
         "bufio"
         "bytes"
         "crypto/rand"
         "crypto/tls"
         "fmt"
         "io"
         "log"
         "net"
         "os"
         "path"
         "runtime"
         "strconv"
         "strings"
         "sync"
-        "syscall"
         "time"
 )
 
 // Errors introduced by the HTTP server.
 var (
         ErrWriteAfterFlush = os.NewError("Conn.Write called after Flush")
         ErrBodyNotAllowed  = os.NewError("http: response status code does not allow body")
         ErrHijacked        = os.NewError("Conn has been hijacked")
         ErrContentLength   = os.NewError("Conn.Write wrote more than the declared Content-Length")
 )
@@ skipping 804 matching lines @@
         if addr == "" {
                 addr = ":http"
         }
         l, e := net.Listen("tcp", addr)
         if e != nil {
                 return e
         }
         return srv.Serve(l)
 }
 
-func errorIsAcceptMaxFiles(err os.Error) bool {
-        ne, ok := err.(*net.OpError)
-        if !ok || ne.Op != "accept" {
-                return false
-        }
-        errno, ok := ne.Error.(os.Errno)
-        return ok && errno == os.Errno(syscall.EMFILE)
-}
-
 // Serve accepts incoming connections on the Listener l, creating a
 // new service thread for each.  The service threads read requests and
 // then call srv.Handler to reply to them.
 func (srv *Server) Serve(l net.Listener) os.Error {
         defer l.Close()
         handler := srv.Handler
         if handler == nil {
                 handler = DefaultServeMux
         }
         for {
                 rw, e := l.Accept()
                 if e != nil {
-                        if errorIsAcceptMaxFiles(e) {
+                        if ne, ok := e.(net.Error); ok && ne.Temporary() {
                                 log.Printf("http: Accept error: %v", e)
                                 continue
                         }
                         return e
                 }
                 if srv.ReadTimeout != 0 {
                         rw.SetReadTimeout(srv.ReadTimeout)
                 }
                 if srv.WriteTimeout != 0 {
                         rw.SetWriteTimeout(srv.WriteTimeout)
@@ skipping 166 matching lines @@
 func (tw *timeoutWriter) WriteHeader(code int) {
         tw.mu.Lock()
         if tw.timedOut || tw.wroteHeader {
                 tw.mu.Unlock()
                 return
         }
         tw.wroteHeader = true
         tw.mu.Unlock()
         tw.w.WriteHeader(code)
 }