Comment arrêter http.ListenAndServe()

Comme mentionné dans yo.ian.g's réponse. Aller 1.8 a inclus cette fonctionnalité dans la lib standard.

Exemple Minimal pour pour Go 1.8+:

    server := &http.Server{Addr: ":8080", Handler: handler}

    go func() {
        if err := server.ListenAndServe(); err != nil {
            //handle err
        }
    }()

    //Setting up signal capturing
    stop := make(chan os.Signal, 1)
    signal.Notify(stop, os.Interrupt)

    //Waiting for SIGINT (pkill -2)
    <-stop

    ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
    defer cancel()
    if err := server.Shutdown(ctx); err != nil {
        //handle err
    }

---

Réponse Originale À Cette Question - Pré Aller 1.8 :

Bâtiment sur Uvelichitel de l' réponse.

Vous pouvez créer votre propre version de ListenAndServe qui retourne un io.Closer et ne se bloque pas.

func ListenAndServeWithClose(addr string, handler http.Handler) (io.Closer,error) {

    var (
        listener  net.Listener
        srvCloser io.Closer
        err       error
    )

    srv := &http.Server{Addr: addr, Handler: handler}

    if addr == "" {
        addr = ":http"
    }

    listener, err = net.Listen("tcp", addr)
    if err != nil {
        return nil, err
    }

    go func() {
        err := srv.Serve(tcpKeepAliveListener{listener.(*net.TCPListener)})
        if err != nil {
            log.Println("HTTP Server Error - ", err)
        }
    }()

    srvCloser = listener
    return srvCloser, nil
}

Code complet disponible ici.

HTTP Serveur se ferme avec le message d'erreur
accept tcp [::]:8080: use of closed network connection

Vous pouvez construire net.Listener

l, err := net.Listen("tcp", fmt.Sprintf(":%d", service.Port()))
if err != nil {
    log.Fatal(err)
}

que vous pouvez Close()

go func(){
    //...
    l.Close()
}()

et http.Serve() sur elle

http.Serve(l, service.router)

Vous pouvez fermer le serveur par la fermeture de son contexte.

type ServeReqs func(ctx context.Context, cfg Config, deps ReqHandlersDependencies) error

var ServeReqsImpl = func(ctx context.Context, cfg Config, deps ReqHandlersDependencies) error {
    http.Handle(pingRoute, decorateHttpRes(pingHandlerImpl(deps.pingRouteResponseMessage), addJsonHeader()))

    server := &http.Server{Addr: fmt.Sprintf(":%d", cfg.port), Handler: nil}

    go func() {
        <-ctx.Done()
        fmt.Println("Shutting down the HTTP server...")
        server.Shutdown(ctx)
    }()

    err := server.ListenAndServeTLS(
        cfg.certificatePemFilePath,
        cfg.certificatePemPrivKeyFilePath,
    )

    //Shutting down the server is not something bad ffs Go...
    if err == http.ErrServerClosed {
        return nil
    }

    return err
}

Et à chaque fois que vous êtes prêt à fermer, composez le:

ctx, closeServer := context.WithCancel(context.Background())
err := ServeReqs(ctx, etc)
closeServer()

Ce que j'ai fait pour de tels cas où l'application est tout le serveur et effectuer aucune autre fonction est d'installer un http.HandleFunc pour un modèle de type /shutdown. Quelque chose comme

http.HandleFunc("/shutdown", func(w http.ResponseWriter, r *http.Request) {
    if <credentials check passes> {
        //- Turn on mechanism to reject incoming requests.
        //- Block until "in-flight" requests complete.
        //- Release resources, both internal and external.
        //- Perform all other cleanup procedures thought necessary
        //  for this to be called a "graceful shutdown".
        fmt.Fprint(w, "Goodbye!\n")
        os.Exit(0)
    }
})

Il ne nécessite pas de 1.8. Mais si la 1.8 est disponible, alors que la solution peut être incorporé ici à la place de la os.Exit(0) appel si cela est souhaitable, je crois.

Le code pour effectuer tous que le travail de nettoyage est laissé comme exercice pour le lecteur.

Un crédit supplémentaire si vous pouvez dire que où que le code de nettoyage pourrait être plus raisonnable de même, je ne recommande pas de le faire ici, et comment ce point de terminaison frappé devrait provoquer l'invocation de ce code.

Plus d'un crédit supplémentaire si vous pouvez dire que où que os.exit(0) appel (ou quel que soit le processus de sortie vous choisissez d'utiliser), donnés ici à titre indicatif, serait la plus raisonnable, placé.

Encore plus le crédit supplémentaire si vous pouvez expliquer pourquoi ce mécanisme de serveur HTTP processus de signalisation doivent être considérés au-dessus de tous les autres mécanismes de la pensée pratique dans ce cas.