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

type bluetool struct {
}

func (bt *bluetool) ServeHTTP(w http.ResponseWriter, r *http.Request) {
	msg := fmt.Sprintf("url is %s
",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))
}