HTTP.ListenAndServe () को कैसे रोकें

Question 1

मैं गोल्ड वेब टूलकिट के साथ गोरिल्ला वेब टूलकिट से एमएक्स लाइब्रेरी का उपयोग कर रहा हूं।

समस्या यह है कि मेरे आवेदन में HTTP सर्वर केवल एक घटक है और इसे मेरे विवेक पर रोकना और शुरू करना आवश्यक है।

जब मैं http.ListenAndServe(fmt.Sprintf(":%d", service.Port()), service.router)इसे ब्लॉक करता हूं और मैं सर्वर को चलने से रोक नहीं सकता।

मुझे पता है कि यह अतीत में एक समस्या रही है, क्या अभी भी ऐसा ही है? क्या कोई नया उपाय है?

Question 2

सुशोभित शटडाउन के बारे में (गो 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")
}

Question 3

जैसा कि yo.ian.gउत्तर में बताया गया है । गो 1.8 ने इस कार्यक्षमता को मानक लिब में शामिल किया है।

इसके लिए न्यूनतम उदाहरण 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.

मूल उत्तर - प्री गो 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

Question 4

गो 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)

प्रासंगिक प्रतिबद्धता यहां पाई जा सकती है

Question 5

आप निर्माण कर सकते हैं 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)

Question 6

चूंकि पिछले उत्तर में से कोई भी नहीं कहता है कि आप ऐसा क्यों नहीं कर सकते हैं यदि आप http.ListenAndServe () का उपयोग करते हैं, तो मैं v1.8 http स्रोत कोड में चला गया और यहां यह कहता है:

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

जैसा कि आप देख सकते हैं http.ListenAndServe फ़ंक्शन सर्वर चर को वापस नहीं करता है। इसका मतलब है कि आपको शटडाउन कमांड का उपयोग करने के लिए 'सर्वर' नहीं मिल सकता है। इसलिए, आपको कार्यान्वित किए जाने वाले सुशोभित शटडाउन के लिए इस फ़ंक्शन का उपयोग करने के बजाय अपना स्वयं का 'सर्वर' उदाहरण बनाने की आवश्यकता है।

Question 7

आप इसके संदर्भ को बंद करके सर्वर को बंद कर सकते हैं।

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

Question 8

ए context.Contextका उपयोग करके इसे हल करना संभव है net.ListenConfig। मेरे मामले में, मैं एक का उपयोग नहीं करना चाहता था sync.WaitGroupया http.Serverकी 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
}

Question 9

मैंने ऐसे मामलों के लिए क्या किया है, जहां आवेदन सिर्फ सर्वर है और कोई अन्य कार्य नहीं कर रहा है 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 सर्वर प्रक्रिया संकेतन की व्यवस्था अन्य सभी तरह के तंत्र ऊपर विचार किया जाना चाहिए इस मामले में व्यावहारिक सोचा।