go-http-unix-socket

package main

import (
    "context"
    "fmt"
    "io"
    "io/ioutil"
    "log"
    "net"
    "net/http"
    "time"
)

var handlersMap = make(map[string]http.HandlerFunc)

func f1(w http.ResponseWriter, r *http.Request) {
    io.WriteString(w, "software is healthy\n")
}

type bluetool struct {
}

func (bt *bluetool) ServeHTTP(w http.ResponseWriter, r *http.Request) {
    msg := fmt.Sprintf("url is %s\n",r.URL.String())
    io.WriteString(w, msg)
    if h, ok := handlersMap[r.URL.String()]; ok {
        h(w, r)
    }
}

func main() {
    sockpath := "/data/unix.socket"

    // server
    bt := new(bluetool)
    handlersMap["/health"] = f1

    // unix socket
    addr, err := net.ResolveUnixAddr("unix", sockpath)
    if err != nil {
        panic("Cannot resolve unix addr: " + err.Error())
    }
    fmt.Println(addr.String())

    listener, err := net.ListenUnix("unix", addr)
    defer listener.Close()
    if err != nil {
        panic("Cannot listen to unix domain socket: " + err.Error())
    }
    fmt.Println("Listening on", listener.Addr())

    donec := make(chan struct{})
    go func() {
        defer close(donec)
        http.Serve(listener, bt)
    }()
    defer func() {
        listener.Close()
        <-donec
    }()


    // client
    defaultTimeout := 10 * time.Second
    tr := new(http.Transport)
    tr.DisableCompression = true
    tr.DialContext = func(_ context.Context, _, _ string) (net.Conn, error) {
        return net.DialTimeout("unix", sockpath, defaultTimeout)
    }
    client := &http.Client{Transport: tr}

    if _, ok := client.Transport.(http.RoundTripper); !ok {
        fmt.Printf("unable to verify TLS configuration, invalid transport %v", client.Transport)
    }


    //url := "http://" + listener.Addr().String() + "/health"
    //pingUrl := url.URL{Scheme:"unix",Host:sockpath, Path:path.Join("/","/health")}
    //fmt.Println(pingUrl)

    var body io.Reader
    body=nil
    request, err := http.NewRequest("GET", "/health", body)
    request.URL.Scheme="http"
    request.URL.Host = sockpath
    // fmt.Println(request)

    resp, err := client.Do(request)
    if err != nil {
        log.Fatalf("fetch error: %v", err)
    }
    b, err := ioutil.ReadAll(resp.Body)
    resp.Body.Close()
    if err != nil {
        log.Fatalf("fetch error: reading %v", err)
    }
    fmt.Println(string(b))
}

转载于:https://www.cnblogs.com/walkinginthesun/p/10397539.html