Go: Jak uruchomić przeglądarkę PO rozpoczęciu nasłuchiwania serwera?

Question

W aplikacji Go, w jaki sposób mogę uruchomić przeglądarkę PO rozpoczęciu nasłuchiwania serwera?
Najlepiej w najprostszy możliwy sposób.

Mój kod tak daleko, super dumbed dół do punktu:

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

Jeśli nie ma błędu, http.ListenAndServe() nigdy nie powróci. Więc nie powinieneś dodawać kodu po tym, oprócz kodu, który obsługuje niepowodzenie.

Musisz rozpocząć nową goroutine, więc ListenAndServe() jest wywoływana w jednej goroutine, a sprawdzanie kodu, czy jest włączone, powinno działać na drugiej Glistemu.

Można sprawdzić, czy serwer działa, wykonując proste wywołanie HTTP GET, na przykład za pomocą http.Get().

Następujący przykład celowo opóźnia rozruch przez 7 sekund. Nowa goroutine uruchamia nieskończoną pętlę for, która sprawdza, czy serwer jest w górze, przesypiając 1 sekundę między próbami.

Przykład:

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

Przykâadowa:

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

Otwórz słuchacz, uruchom przeglądarkę i wprowadź pętli serwera:

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

nie ma potrzeby odpytywania jako przedstawione w innej odpowiedzi. Przeglądarka połączy się, jeśli gniazdo nasłuchu jest otwarte przed uruchomieniem przeglądarki.

ListenAndServe to wygodna funkcja, która otwiera gniazdo i dzwoni pod Serwuj. Kod w tej odpowiedzi dzieli te kroki, aby przeglądarka mogła zostać otwarta po rozpoczęciu odsłuchu, ale przed blokowaniem połączenia z serwerem.