返回响应后关闭 HTTP 服务器

Question

我正在构建一个与 Instagram 交互的基于命令行的小型 Go 机器人 API。

Instagram API 是基于 OAuth 的，因此对于基于命令行的应用来说并不太好。

为了解决这个问题，我在浏览器中打开适当的授权 URL 并使用本地服务器为重定向 URI 旋转 - 这样我就可以捕获并优雅地显示访问令牌，而不是给需要从 URL 手动获取的用户。

到目前为止一切顺利，应用程序可以成功打开浏览器到授权 URL，您授权它，它会将您重定向到本地 HTTP 服务器。

现在，在向用户显示访问令牌后我不需要 HTTP 服务器，因此我想在执行此操作后手动关闭服务器。

为了做到这一点，我从这个 answer 中得到灵感，并总结出以下内容：

package main

import (
    "fmt"
    "io"
    "log"
    "net/http"
    "os/exec"
    "runtime"
    "time"
)

var client_id = "my_client_id"
var client_secret = "my_client_secret"
var redirect_url = "http://localhost:8000/instagram/callback"

func main() {

    srv := startHttpServer()

    openbrowser(fmt.Sprintf("https://api.instagram.com/oauth/authorize/?client_id=%v&redirect_uri=%v&response_type=code", client_id, redirect_url))

    // Backup to gracefully shutdown the server
    time.Sleep(20 * time.Second)
    if err := srv.Shutdown(nil); err != nil {
        panic(err) // failure/timeout shutting down the server gracefully
    }
}

func showTokenToUser(w http.ResponseWriter, r *http.Request, srv *http.Server) {
    io.WriteString(w, fmt.Sprintf("Your access token is: %v", r.URL.Query().Get("code")))
    if err := srv.Shutdown(nil); err != nil {
        log.Fatal(err) // failure/timeout shutting down the server gracefully
    }
}

func startHttpServer() *http.Server {
    srv := &http.Server{Addr: ":8000"}

    http.HandleFunc("/instagram/callback", func(w http.ResponseWriter, r *http.Request) {
        showTokenToUser(w, r, srv)
    })

    go func() {
        if err := srv.ListenAndServe(); err != nil {
            // cannot panic, because this probably is an intentional close
            log.Printf("Httpserver: ListenAndServe() error: %s", err)
        }
    }()

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

func openbrowser(url string) {
    var err error

    switch runtime.GOOS {
    case "linux":
        err = exec.Command("xdg-open", url).Start()
    case "windows":
        err = exec.Command("rundll32", "url.dll,FileProtocolHandler", url).Start()
    case "darwin":
        err = exec.Command("open", url).Start()
    default:
        err = fmt.Errorf("unsupported platform")
    }
    if err != nil {
        log.Fatal(err)
    }
}

然而，上述导致此错误：

2017/11/23 16:02:03 Httpserver: ListenAndServe() error: http: Server closed

2017/11/23 16:02:03 http: panic serving [::1]:61793: runtime error: invalid memory address or nil pointer dereference

如果我在处理程序中注释掉这些行，那么它就可以完美地工作，尽管在我点击回调路由时没有关闭服务器：

if err := srv.Shutdown(nil); err != nil {
    log.Fatal(err) // failure/timeout shutting down the server gracefully
}

我哪里错了？我需要更改什么才能在向用户显示文本后点击回调路由时关闭服务器。

Answer 1

Shutdown 函数接受参数 ctx context.Context。尝试向它传递一个空的上下文。

ctx := context.Background()

另外：

When Shutdown is called, Serve, ListenAndServe, and ListenAndServeTLS immediately return ErrServerClosed. Make sure the program doesn't exit and waits instead for Shutdown to return.

Answer 2

您可以使用 context.WithCancel:

package main

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

func main() {
    ctx, cancel := context.WithCancel(context.Background())

    http.HandleFunc("/quit", func(w http.ResponseWriter, r *http.Request) {
        io.WriteString(w, "Bye\n")
        cancel()
    })
    http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
        io.WriteString(w, "Hi\n")
    })

    srv := &http.Server{Addr: ":8080"}
    go func() {
        err := srv.ListenAndServe()
        if err != http.ErrServerClosed {
            log.Println(err)
        }
    }()

    <-ctx.Done() // wait for the signal to gracefully shutdown the server

    // gracefully shutdown the server:
    // waiting indefinitely for connections to return to idle and then shut down.
    err := srv.Shutdown(context.Background())
    if err != nil {
        log.Println(err)
    }

    log.Println("done.")
}

The same Context 可以传递给不同 goroutines 中的函数运行：

"Contexts are safe for simultaneous use by multiple goroutines."

您可以使用相同的 context - 如果您不想等待外部：

package main

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

func main() {
    ctx, cancel := context.WithCancel(context.Background())
    http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
        io.WriteString(w, "Hi\n")
    })
    http.HandleFunc("/quit", func(w http.ResponseWriter, r *http.Request) {
        io.WriteString(w, "Bye\n")
        cancel()
    })
    srv := &http.Server{Addr: ":8080"}
    go func() {
        if err := srv.ListenAndServe(); err != nil {
            log.Printf("Httpserver: ListenAndServe() error: %s", err)
        }
    }()
    <-ctx.Done()
    // if err := srv.Shutdown(ctx); err != nil && err != context.Canceled {
    //  log.Println(err)
    // }
    log.Println("done.")
}

Server.Shutdown:
Shutdown 在不中断任何活动连接的情况下优雅地关闭服务器。 Shutdown 的工作原理是首先关闭所有打开的侦听器，然后关闭所有空闲连接，然后无限期 等待到 return 的连接空闲，然后关闭。如果提供的上下文在关闭完成之前过期，则 Shutdown returns 上下文的错误，否则它 returns 任何因关闭服务器的底层 Listenerreturn 而导致的错误。

调用 Shutdown 时，Serve、ListenAndServe 和 ListenAndServeTLS 立即 returnErrServerClosed。确保程序不会退出并等待关机到 return.

Shutdown 不会尝试关闭或等待被劫持的连接，例如 WebSockets。如果需要，Shutdown 的调用者应单独通知此类长期连接关闭并等待它们关闭。有关注册关机通知功能的方法，请参阅 RegisterOnShutdown。

一旦在服务器上调用了 Shutdown，就不能再使用它；以后对 Serve 等方法的调用将 return ErrServerClosed。

返回响应后关闭 HTTP 服务器

Shutting down HTTP server after returning response

go

httpserver