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