160 lines
3.3 KiB
Go
160 lines
3.3 KiB
Go
package main
|
|
|
|
import (
|
|
"encoding/json"
|
|
"flag"
|
|
"fmt"
|
|
"sync"
|
|
|
|
"github.com/gorilla/websocket"
|
|
// "github.com/pkg/profile"
|
|
"log"
|
|
"net"
|
|
"net/http"
|
|
"net/url"
|
|
"os"
|
|
"time"
|
|
)
|
|
|
|
var port string
|
|
|
|
func init() {
|
|
flag.StringVar(&port, "port", "80", "give me a port number")
|
|
}
|
|
|
|
var upgrader = websocket.Upgrader{
|
|
ReadBufferSize: 1024,
|
|
WriteBufferSize: 1024,
|
|
}
|
|
|
|
func main() {
|
|
// defer profile.Start().Stop()
|
|
flag.Parse()
|
|
http.HandleFunc("/echo", echoHandler)
|
|
http.HandleFunc("/bench", benchHandler)
|
|
http.HandleFunc("/", whoamI)
|
|
http.HandleFunc("/api", api)
|
|
http.HandleFunc("/health", healthHandler)
|
|
fmt.Println("Starting up on port " + port)
|
|
log.Fatal(http.ListenAndServe(":"+port, nil))
|
|
}
|
|
|
|
func printBinary(s []byte) {
|
|
fmt.Printf("Received b:")
|
|
for n := 0; n < len(s); n++ {
|
|
fmt.Printf("%d,", s[n])
|
|
}
|
|
fmt.Printf("\n")
|
|
}
|
|
func benchHandler(w http.ResponseWriter, r *http.Request) {
|
|
// body := "Hello World\n"
|
|
w.Header().Set("Connection", "keep-alive")
|
|
w.Header().Set("Content-Type", "text/plain")
|
|
// fmt.Fprint(w, body)
|
|
}
|
|
func echoHandler(w http.ResponseWriter, r *http.Request) {
|
|
conn, err := upgrader.Upgrade(w, r, nil)
|
|
if err != nil {
|
|
log.Println(err)
|
|
return
|
|
}
|
|
for {
|
|
messageType, p, err := conn.ReadMessage()
|
|
if err != nil {
|
|
return
|
|
}
|
|
printBinary(p)
|
|
err = conn.WriteMessage(messageType, p)
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
}
|
|
|
|
func whoamI(w http.ResponseWriter, req *http.Request) {
|
|
u, _ := url.Parse(req.URL.String())
|
|
queryParams := u.Query()
|
|
wait := queryParams.Get("wait")
|
|
if len(wait) > 0 {
|
|
duration, err := time.ParseDuration(wait)
|
|
if err == nil {
|
|
time.Sleep(duration)
|
|
}
|
|
}
|
|
hostname, _ := os.Hostname()
|
|
fmt.Fprintln(w, "Hostname:", hostname)
|
|
ifaces, _ := net.Interfaces()
|
|
for _, i := range ifaces {
|
|
addrs, _ := i.Addrs()
|
|
// handle err
|
|
for _, addr := range addrs {
|
|
var ip net.IP
|
|
switch v := addr.(type) {
|
|
case *net.IPNet:
|
|
ip = v.IP
|
|
case *net.IPAddr:
|
|
ip = v.IP
|
|
}
|
|
fmt.Fprintln(w, "IP:", ip)
|
|
}
|
|
}
|
|
req.Write(w)
|
|
}
|
|
|
|
func api(w http.ResponseWriter, req *http.Request) {
|
|
hostname, _ := os.Hostname()
|
|
data := struct {
|
|
Hostname string `json:"hostname,omitempty"`
|
|
IP []string `json:"ip,omitempty"`
|
|
Headers http.Header `json:"headers,omitempty"`
|
|
}{
|
|
hostname,
|
|
[]string{},
|
|
req.Header,
|
|
}
|
|
|
|
ifaces, _ := net.Interfaces()
|
|
for _, i := range ifaces {
|
|
addrs, _ := i.Addrs()
|
|
// handle err
|
|
for _, addr := range addrs {
|
|
var ip net.IP
|
|
switch v := addr.(type) {
|
|
case *net.IPNet:
|
|
ip = v.IP
|
|
case *net.IPAddr:
|
|
ip = v.IP
|
|
}
|
|
data.IP = append(data.IP, ip.String())
|
|
}
|
|
}
|
|
json.NewEncoder(w).Encode(data)
|
|
}
|
|
|
|
type healthState struct {
|
|
StatusCode int
|
|
}
|
|
|
|
var currentHealthState = healthState{200}
|
|
var mutexHealthState = &sync.RWMutex{}
|
|
|
|
func healthHandler(w http.ResponseWriter, req *http.Request) {
|
|
if req.Method == http.MethodPost {
|
|
var statusCode int
|
|
err := json.NewDecoder(req.Body).Decode(&statusCode)
|
|
if err != nil {
|
|
w.WriteHeader(http.StatusBadRequest)
|
|
w.Write([]byte(err.Error()))
|
|
} else {
|
|
fmt.Printf("Update health check status code [%d]\n", statusCode)
|
|
mutexHealthState.Lock()
|
|
defer mutexHealthState.Unlock()
|
|
currentHealthState.StatusCode = statusCode
|
|
}
|
|
} else {
|
|
mutexHealthState.RLock()
|
|
defer mutexHealthState.RUnlock()
|
|
w.WriteHeader(currentHealthState.StatusCode)
|
|
}
|
|
}
|