11

我有一个托管简单 HTTP 服务的 Go 程序，localhost:8080因此我可以nginx通过该指令将我的公共主机连接到它proxy_pass，作为反向代理来服务我网站的部分请求。这一切都很好，没有问题。

我想将 Go 程序转换为在 Unix 域套接字而不是本地 TCP 套接字上托管 HTTP 服务，以提高安全性并减少 TCP 的不必要的协议开销。

问题bind()：问题是 Unix 域套接字一旦被重用，即使在程序终止后也不能重用。第二次（以及之后的每次）我运行 Go 程序，它以致命错误退出"address already in use"。

常见的做法是unlink()在服务器关闭时对 Unix 域套接字（即删除文件）。但是，这在 Go 中很棘手。我的第一次尝试是defer在我的主函数中使用该语句（见下文），但如果我用 CTRL-C 之类的信号中断进程，它就不会运行。我想这是可以预料的。令人失望，但并不意外。

问题unlink()：当服务器进程关闭（优雅或不优雅）时，是否有关于如何连接套接字的最佳实践？

这是我func main()启动服务器监听以供参考的一部分：

// Create the HTTP server listening on the requested socket:
l, err := net.Listen("unix", "/tmp/mysocket")
if err != nil {
    log.Fatal(err)
} else {
    // Unix sockets must be unlink()ed before being reused again.
    // Unfortunately, this defer is not run when a signal is received, e.g. CTRL-C.
    defer func() {
        os.Remove("/tmp/mysocket")
    }()

    log.Fatal(http.Serve(l, http.HandlerFunc(indexHtml)))
}
4

3 回答 3

8

这是我使用的完整解决方案。我在我的问题中发布的代码是用于清晰演示目的的简化版本。

// Create the socket to listen on:
l, err := net.Listen(socketType, socketAddr)
if err != nil {
    log.Fatal(err)
    return
}

// Unix sockets must be unlink()ed before being reused again.

// Handle common process-killing signals so we can gracefully shut down:
sigc := make(chan os.Signal, 1)
signal.Notify(sigc, os.Interrupt, os.Kill, syscall.SIGTERM)
go func(c chan os.Signal) {
    // Wait for a SIGINT or SIGKILL:
    sig := <-c
    log.Printf("Caught signal %s: shutting down.", sig)
    // Stop listening (and unlink the socket if unix type):
    l.Close()
    // And we're done:
    os.Exit(0)
}(sigc)

// Start the HTTP server:
log.Fatal(http.Serve(l, http.HandlerFunc(indexHtml)))

我当然希望这是让 Go 作者感到自豪的优秀且有效的 Go 代码。在我看来确实如此。如果不是，那对我来说会很尴尬。:)

对于任何好奇的人，这是https://github.com/JamesDunne/go-index-html的一部分，它是一个简单的 HTTP 目录列表生成器，具有一些 Web 服务器不提供的额外功能。

于 2013-05-22T21:50:45.223 回答
2

您可以使用信号处理程序结束您的主函数，并为您的其他任务生成单独的 go 例程。这样，您可以利用延迟机制并干净地处理所有（基于或不基于信号的）关闭：

func main() {
    // Create the HTTP server listening on the requested socket:
    l, err := net.Listen("unix", "/tmp/mysocket")
    if err != nil {
        log.Fatal(err)
        return
    }
    // Just work with defer here; this works as long as the signal handling
    // happens in the main Go routine.
    defer l.Close()

    // Make sure the server does not block the main
    go func() {
        log.Fatal(http.Serve(l, http.HandlerFunc(indexHtml)))
    }()


    // Use a buffered channel so we don't miss any signals
    c := make(chan os.Signal, 1)
    signal.Notify(c, os.Interrupt, os.Kill, syscall.SIGTERM)

    // Block until a signal is received.
    s := <-c
    fmt.Println("Got signal:", s)

    // ...and exit, running all the defer statements
}
于 2014-08-11T12:10:20.323 回答
2

在现代 Go 中，您可以在此处syscall.Unlink()使用- 文档：

import ( 
    "net"
    "syscall"
    ...
)

...


socketpath := "/tmp/somesocket"
// carry on with your socket creation:
addr, err := net.ResolveUnixAddr("unixgram", socketpath)
if err != nil {
    return err;
}

// always remove the named socket from the fs if its there
err = syscall.Unlink(socketpath)
if err != nil {
    // not really important if it fails
    log.Error("Unlink()",err)
}

// carry on with socket bind()
conn, err := net.ListenUnixgram("unixgram", addr);
if err != nil {
    return err;
}
于 2016-11-21T20:33:06.310 回答