जाओ: सर्वर ने सुनना शुरू करने के बाद ब्राउज़र कैसे शुरू कर सकता हूं?

Question

गो में, सर्वर ने सुनना शुरू करने के बाद ब्राउज़र कैसे शुरू कर सकता हूं?
पसंदीदा रूप से सबसे आसान तरीका संभव है।

मेरे कोड अब तक, बात करने के लिए नीचे सुपर dumbed:

package main 

import ( 
    // Standard library packages 
    "fmt" 
    "net/http" 
    "github.com/skratchdot/open-golang/open" 
    // Third party packages 
    "github.com/julienschmidt/httprouter" 
) 


// go get github.com/toqueteos/webbrowser 

func main() { 
    // Instantiate a new router 
    r := httprouter.New() 

    // Add a handler on /test 
    r.GET("/test", func(w http.ResponseWriter, r *http.Request, _ httprouter.Params) { 
     // Simply write some test data for now 
     fmt.Fprint(w, "Welcome!\n") 
    }) 

    //open.Run("https://google.com/") 

    // open.Start("https://google.com") 

    // http://127.0.0.1:3000/test 
    // Fire up the server 
    http.ListenAndServe("localhost:3000", r) 
    fmt.Println("ListenAndServe is blocking") 
    open.RunWith("http://localhost:3000/test", "firefox") 
    fmt.Println("Done") 
} 

Answer 1

अगर कोई त्रुटि है, http.ListenAndServe() वापस कभी नहीं होगा। इसलिए आपको कोड को उस कोड को छोड़कर नहीं जोड़ना चाहिए जो विफलता को संभालता है।

आपको एक नया goroutine शुरू करना है, इसलिए ListenAndServe() को एक goroutine में बुलाया जाता है, और कोड जांच अगर यह ऊपर है तो अन्य goroutine पर चलना चाहिए।

और आप यह जांच सकते हैं कि आपका सर्वर एक सरल HTTP GET इसे कॉल करके बना रहा है, उदाहरण के लिए http.Get() का उपयोग कर।

निम्नलिखित उदाहरण उद्देश्य पर 7 सेकंड के लिए स्टार्टअप देरी करता है। नया goroutine एक अंतहीन for लूप शुरू करता है जो जांचता है कि सर्वर चालू है या नहीं, प्रयासों के बीच 1 सेकंड सो रहा है।

उदाहरण:

http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) { 
    w.Write([]byte("Hi!")) 
}) 

go func() { 
    for { 
     time.Sleep(time.Second) 

     log.Println("Checking if started...") 
     resp, err := http.Get("http://localhost:8081") 
     if err != nil { 
      log.Println("Failed:", err) 
      continue 
     } 
     resp.Body.Close() 
     if resp.StatusCode != http.StatusOK { 
      log.Println("Not OK:", resp.StatusCode) 
      continue 
     } 

     // Reached this point: server is up and running! 
     break 
    } 
    log.Println("SERVER UP AND RUNNING!") 
}() 

log.Println("Starting server...") 
time.Sleep(time.Second * 7) 
log.Fatal(http.ListenAndServe(":8081", nil)) 

उदाहरण आउटपुट:

2015/09/23 13:53:03 Starting server... 
2015/09/23 13:53:04 Checking if started... 
2015/09/23 13:53:06 Failed: Get http://localhost:8081: dial tcp [::1]:8081: connectex: No connection could be made because the target machine actively refused it. 
2015/09/23 13:53:07 Checking if started... 
2015/09/23 13:53:09 Failed: Get http://localhost:8081: dial tcp [::1]:8081: connectex: No connection could be made because the target machine actively refused it. 
2015/09/23 13:53:10 Checking if started... 
2015/09/23 13:53:10 SERVER UP AND RUNNING! 

Answer 2

ओपन श्रोता, ब्राउज़र शुरू हुई और फिर सर्वर पाश दर्ज करें:

l, err := net.Listen("tcp", "localhost:3000") 
if err != nil { 
    log.Fatal(err) 
} 

// The browser can connect now because the listening socket is open. 

err := open.Start("http://localhost:3000/test") 
if err != nil { 
    log.Println(err) 
} 

// Start the blocking server loop. 

log.Fatal(http.Serve(l, r)) 

के रूप में मतदान पर कोई ज़रूरत नहीं है एक और जवाब में दिखाया गया। यदि ब्राउजर शुरू होने से पहले सुनना सॉकेट खुला है तो ब्राउजर कनेक्ट होगा।

सुनो एंडसर्व एक सुविधा समारोह है जो एक सॉकेट खोलता है और सेवा करता है। इस जवाब में कोड इन चरणों को विभाजित करता है ताकि ब्राउज़िंग शुरू होने के बाद ब्राउजर खोला जा सके लेकिन सेवा करने के लिए अवरुद्ध कॉल से पहले।