Files

157 lines
5.1 KiB
Go

package server
import (
"context"
"encoding/json"
"io"
"net"
"net/http"
"net/url"
"os"
"sort"
"strconv"
"time"
"git.a-wan.net/alan/pipelines/internal/protocol"
)
func networkAddresses() []protocol.NetworkAddress {
result := []protocol.NetworkAddress{}
interfaces, _ := net.Interfaces()
for _, iface := range interfaces {
if iface.Flags&net.FlagUp == 0 {
continue
}
addresses, _ := iface.Addrs()
for _, address := range addresses {
ip, _, err := net.ParseCIDR(address.String())
if err != nil || ip.IsUnspecified() {
continue
}
text := ip.String()
if ip.IsLinkLocalUnicast() && ip.To4() == nil {
text += "%" + iface.Name
}
result = append(result, protocol.NetworkAddress{Interface: iface.Name, IP: text})
}
}
sort.Slice(result, func(i, j int) bool {
if result[i].Interface != result[j].Interface {
return result[i].Interface < result[j].Interface
}
return result[i].IP < result[j].IP
})
return result
}
func endpointPort(u *url.URL) string {
if port := u.Port(); port != "" {
return port
}
if u.Scheme == "https" || u.Scheme == "wss" {
return "443"
}
return "80"
}
func candidateURLs(addresses []protocol.NetworkAddress, scheme, port, path string) []string {
result := []string{}
for _, address := range addresses {
u := url.URL{Scheme: scheme, Host: net.JoinHostPort(address.IP, port), Path: path}
result = append(result, u.String())
}
return result
}
func localEndpoint(u *url.URL, hostname string, addresses []protocol.NetworkAddress) bool {
host := u.Hostname()
if host == "localhost" || host == hostname || net.ParseIP(host).IsLoopback() {
return true
}
for _, address := range addresses {
if host == address.IP {
return true
}
}
return false
}
func systemStatus(r *http.Request, started time.Time, runErr error) *protocol.SystemStatus {
hostname, _ := os.Hostname()
s := &protocol.SystemStatus{Hostname: hostname, StartedAt: started.UTC().Format(time.RFC3339), Uptime: time.Since(started).Round(time.Second).String(), Addresses: networkAddresses(), Server: protocol.ServiceStatus{Health: "healthy"}, Ntfy: protocol.ServiceStatus{Health: "not configured"}, Note: "Addresses belong to the server computer (or container). Candidate URLs are not reachability checks; binding, firewalls, port mapping and TLS may differ."}
if runErr != nil {
s.Server.Health = "execution unavailable"
}
if address, ok := r.Context().Value(http.LocalAddrContextKey).(net.Addr); ok {
_, port, err := net.SplitHostPort(address.String())
if err == nil {
scheme := "ws"
if r.TLS != nil {
scheme = "wss"
}
s.Server.URL = (&url.URL{Scheme: scheme, Host: address.String(), Path: "/connect"}).String()
s.Server.Port = port
s.Server.Candidates = candidateURLs(s.Addresses, scheme, port, "/connect")
}
}
// Docker interface addresses are not the host's connection addresses. The
// installer publishes the detected host LAN IP and actual mapped host port.
if ip := net.ParseIP(os.Getenv("PIPELINES_HOST_IP")); ip != nil && !ip.IsLoopback() && !ip.IsUnspecified() {
if port, err := strconv.Atoi(os.Getenv("PIPELINES_PUBLIC_PORT")); err == nil && port > 0 && port <= 65535 {
s.Server.Port = strconv.Itoa(port)
s.Server.URL = (&url.URL{Scheme: "ws", Host: net.JoinHostPort(ip.String(), s.Server.Port), Path: "/connect"}).String()
s.Addresses = []protocol.NetworkAddress{{Interface: "LAN", IP: ip.String()}}
s.Server.Candidates = []string{s.Server.URL}
}
}
endpoints := notificationEndpoints()
if len(endpoints) == 0 {
return s
}
s.Topic = endpoints[0].Topic
s.NtfyUser = os.Getenv("PIPELINES_NTFY_READER")
s.Ntfy.Health = "not checked"
// Only the validated public base is returned. Publishing URL and tokens
// never leave the server, even on probe failure.
s.Ntfy.URL = endpoints[0].ServerURL
if u, err := url.Parse(s.Ntfy.URL); err == nil && u.Host != "" {
s.Ntfy.Port = endpointPort(u)
if localEndpoint(u, hostname, s.Addresses) {
s.Ntfy.Candidates = candidateURLs(s.Addresses, u.Scheme, s.Ntfy.Port, "/"+s.Topic)
}
}
publish, err := url.Parse(os.Getenv("PIPELINES_NTFY_URL"))
if err != nil {
return s
}
if s.Ntfy.URL == "" && localEndpoint(publish, hostname, s.Addresses) {
s.Ntfy.Port = endpointPort(publish)
s.Ntfy.Candidates = candidateURLs(s.Addresses, publish.Scheme, s.Ntfy.Port, "/"+s.Topic)
}
publish.Path = "/v1/health"
publish.RawPath = ""
publish.RawQuery = ""
publish.Fragment = ""
ctx, cancel := context.WithTimeout(r.Context(), 2*time.Second)
defer cancel()
req, err := http.NewRequestWithContext(ctx, http.MethodGet, publish.String(), nil)
if err != nil {
return s
}
client := &http.Client{CheckRedirect: func(*http.Request, []*http.Request) error { return http.ErrUseLastResponse }}
response, err := client.Do(req)
s.Ntfy.Health = "unreachable"
if err != nil {
return s
}
defer response.Body.Close()
s.Ntfy.Health = "unhealthy"
var health struct {
Healthy bool `json:"healthy"`
}
if response.StatusCode == http.StatusOK && json.NewDecoder(io.LimitReader(response.Body, 4096)).Decode(&health) == nil && health.Healthy {
s.Ntfy.Health = "healthy"
}
return s
}