วิธีหยุด http.ListenAndServe ()

ฉันใช้ไลบรารี Mux จาก Gorilla Web Toolkit พร้อมกับเซิร์ฟเวอร์ Go http ที่ให้มา

ปัญหาคือในแอปพลิเคชันของฉันเซิร์ฟเวอร์ HTTP เป็นเพียงส่วนประกอบเดียวและจำเป็นต้องหยุดและเริ่มต้นตามดุลยพินิจของฉัน

เมื่อฉันเรียกhttp.ListenAndServe(fmt.Sprintf(":%d", service.Port()), service.router)มันว่าบล็อกและดูเหมือนว่าฉันจะหยุดเซิร์ฟเวอร์ไม่ให้ทำงานไม่ได้

ฉันทราบว่าปัญหานี้เคยเป็นปัญหาในอดีตยังคงเป็นเช่นนั้นอยู่หรือไม่? มีโซลูชันใหม่ ๆ หรือไม่?

เกี่ยวกับการปิดระบบอย่างสง่างาม (แนะนำใน Go 1.8) ตัวอย่างที่เป็นรูปธรรมอีกเล็กน้อย:

package main

import (
    "context"
    "io"
    "log"
    "net/http"
    "sync"
    "time"
)

func startHttpServer(wg *sync.WaitGroup) *http.Server {
    srv := &http.Server{Addr: ":8080"}

    http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
        io.WriteString(w, "hello world\n")
    })

    go func() {
        defer wg.Done() // let main know we are done cleaning up

        // always returns error. ErrServerClosed on graceful close
        if err := srv.ListenAndServe(); err != http.ErrServerClosed {
            // unexpected error. port in use?
            log.Fatalf("ListenAndServe(): %v", err)
        }
    }()

    // returning reference so caller can call Shutdown()
    return srv
}

func main() {
    log.Printf("main: starting HTTP server")

    httpServerExitDone := &sync.WaitGroup{}

    httpServerExitDone.Add(1)
    srv := startHttpServer(httpServerExitDone)

    log.Printf("main: serving for 10 seconds")

    time.Sleep(10 * time.Second)

    log.Printf("main: stopping HTTP server")

    // now close the server gracefully ("shutdown")
    // timeout could be given with a proper context
    // (in real world you shouldn't use TODO()).
    if err := srv.Shutdown(context.TODO()); err != nil {
        panic(err) // failure/timeout shutting down the server gracefully
    }

    // wait for goroutine started in startHttpServer() to stop
    httpServerExitDone.Wait()

    log.Printf("main: done. exiting")
}

ดังที่กล่าวไว้ในyo.ian.gคำตอบของ Go 1.8 ได้รวมฟังก์ชันนี้ไว้ใน lib มาตรฐาน

ตัวอย่างน้อยที่สุดสำหรับ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
    }

    // Wait for ListenAndServe goroutine to close.

คำตอบเดิม - Pre Go 1.8:

สร้างจากคำตอบของ Uvelichitel

คุณสามารถสร้างเวอร์ชันของคุณเองListenAndServeซึ่งจะส่งคืนio.Closerและไม่บล็อก

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
}

รหัสเต็มมีที่นี่

เซิร์ฟเวอร์ HTTP จะปิดลงพร้อมกับข้อผิดพลาด accept tcp [::]:8080: use of closed network connection

Go 1.8 จะรวมถึงการปิดระบบที่สง่างามและมีประสิทธิภาพพร้อมใช้งานผ่านServer::Shutdown(context.Context)และServer::Close()ตามลำดับ

go func() {
    httpError := srv.ListenAndServe(address, handler)
    if httpError != nil {
        log.Println("While serving HTTP: ", httpError)
    }
}()

srv.Shutdown(context)

การคอมมิตที่เกี่ยวข้องสามารถพบได้ที่นี่

คุณสามารถสร้าง net.Listener

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

ซึ่งคุณสามารถทำได้ Close()

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

และhttp.Serve()กับมัน

http.Serve(l, service.router)

เนื่องจากไม่มีคำตอบก่อนหน้านี้บอกว่าทำไมคุณถึงทำไม่ได้ถ้าคุณใช้ http.ListenAndServe () ฉันจึงเข้าไปในซอร์สโค้ด v1.8 http และนี่คือสิ่งที่กล่าวว่า:

func ListenAndServe(addr string, handler Handler) error {
    server := &Server{Addr: addr, Handler: handler}
    return server.ListenAndServe()
}

ดังที่คุณเห็นฟังก์ชัน http.ListenAndServe ไม่ส่งคืนตัวแปรเซิร์ฟเวอร์ ซึ่งหมายความว่าคุณไม่สามารถไปที่ 'เซิร์ฟเวอร์' เพื่อใช้คำสั่งปิดเครื่องได้ ดังนั้นคุณต้องสร้างอินสแตนซ์ 'เซิร์ฟเวอร์' ของคุณเองแทนที่จะใช้ฟังก์ชั่นนี้เพื่อให้การปิดระบบเป็นไปอย่างราบรื่น

คุณสามารถปิดเซิร์ฟเวอร์ได้โดยปิดบริบท

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
}

และเมื่อใดก็ตามที่คุณพร้อมที่จะปิดให้โทร:

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

เป็นไปได้ที่จะแก้ปัญหานี้โดยcontext.Contextใช้ไฟล์net.ListenConfig. ในกรณีของฉันฉันไม่ต้องการที่จะใช้sync.WaitGroupหรือhttp.Server's Shutdown()โทรและแทนที่จะพึ่งพาcontext.Context(ซึ่งถูกปิดด้วยสัญญาณ)

import (
  "context"
  "http"
  "net"
  "net/http/pprof"
)

func myListen(ctx context.Context, cancel context.CancelFunc) error {
  lc := net.ListenConfig{}
  ln, err := lc.Listen(ctx, "tcp4", "127.0.0.1:6060")
  if err != nil {
    // wrap the err or log why the listen failed
    return err
  }

  mux := http.NewServeMux()
  mux.Handle("/debug/pprof/", pprof.Index)
  mux.Handle("/debug/pprof/cmdline", pprof.CmdLine)
  mux.Handle("/debug/pprof/profile", pprof.Profile)
  mux.Handle("/debug/pprof/symbol", pprof.Symbol)
  mux.Handle("/debug/pprof/trace", pprof.Trace)

  go func() {
    if err := http.Serve(l, mux); err != nil {
      cancel()
      // log why we shut down the context
      return err
    }
  }()

  // If you want something semi-synchronous, sleep here for a fraction of a second

  return nil
}

สิ่งที่ฉันทำในกรณีเช่นนี้ที่แอปพลิเคชันเป็นเพียงเซิร์ฟเวอร์และไม่มีฟังก์ชันอื่นใดที่ติดตั้งhttp.HandleFuncสำหรับรูปแบบเช่น/shutdown. สิ่งที่ต้องการ

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)
    }
})

ไม่ต้องใช้ 1.8 แต่ถ้า 1.8 พร้อมใช้งานโซลูชันนั้นสามารถฝังที่นี่แทนการos.Exit(0)โทรถ้าต้องการฉันเชื่อ

รหัสสำหรับดำเนินการล้างข้อมูลทั้งหมดจะถูกปล่อยให้เป็นแบบฝึกหัดสำหรับผู้อ่าน

เครดิตพิเศษหากคุณสามารถบอกได้ว่ารหัสการล้างข้อมูลนั้นควรวางไว้ที่ใดอย่างสมเหตุสมผลที่สุดเพราะฉันไม่แนะนำให้ทำที่นี่และวิธีการที่จุดสิ้นสุดนี้จะทำให้เกิดการเรียกใช้รหัสนั้น

เครดิตพิเศษเพิ่มเติมหากคุณสามารถพูดได้ว่าการos.exit(0)โทรนั้น(หรือกระบวนการใดก็ตามที่คุณเลือกใช้) ให้ไว้ที่นี่เพื่อเป็นภาพประกอบเท่านั้นจะได้รับการจัดวางอย่างสมเหตุสมผลที่สุด

แต่เครดิตแม้พิเศษมากขึ้นถ้าคุณสามารถอธิบายได้ว่าทำไมนี้กลไกของการส่งสัญญาณ HTTP กระบวนการเซิร์ฟเวอร์ควรได้รับการพิจารณาข้างต้นกลไกอื่น ๆ ทุกคนคิดว่าสามารถทำงานได้ในกรณีนี้