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