2024-05-09 22:56:16 -04:00
package endpoint
2021-10-23 16:47:12 -04:00
import (
"bytes"
"crypto/x509"
"encoding/json"
"errors"
2022-12-06 01:37:05 -05:00
"fmt"
2021-12-03 14:44:17 +08:00
"io"
2026-02-09 01:08:59 +01:00
"maps"
2025-07-19 19:24:03 -06:00
"math/rand"
2021-10-23 16:47:12 -04:00
"net"
"net/http"
"net/url"
2025-07-19 19:24:03 -06:00
"regexp"
"strconv"
2021-10-23 16:47:12 -04:00
"strings"
"time"
2022-12-06 01:41:09 -05:00
"github.com/TwiN/gatus/v5/alerting/alert"
"github.com/TwiN/gatus/v5/client"
2024-05-09 22:56:16 -04:00
"github.com/TwiN/gatus/v5/config/endpoint/dns"
sshconfig "github.com/TwiN/gatus/v5/config/endpoint/ssh"
"github.com/TwiN/gatus/v5/config/endpoint/ui"
2025-09-05 15:39:12 -04:00
"github.com/TwiN/gatus/v5/config/gontext"
"github.com/TwiN/gatus/v5/config/key"
2025-03-20 16:31:14 -04:00
"github.com/TwiN/gatus/v5/config/maintenance"
2023-09-23 14:37:24 -03:00
"golang.org/x/crypto/ssh"
2021-10-23 16:47:12 -04:00
)
2024-05-09 22:56:16 -04:00
type Type string
2022-05-17 09:10:45 +08:00
2021-10-23 16:47:12 -04:00
const (
// HostHeader is the name of the header used to specify the host
HostHeader = "Host"
// ContentTypeHeader is the name of the header used to specify the content type
ContentTypeHeader = "Content-Type"
// UserAgentHeader is the name of the header used to specify the request's user agent
UserAgentHeader = "User-Agent"
// GatusUserAgent is the default user agent that Gatus uses to send requests.
GatusUserAgent = "Gatus/1.0"
2022-05-17 09:10:45 +08:00
2024-05-09 22:56:16 -04:00
TypeDNS Type = "DNS"
TypeTCP Type = "TCP"
TypeSCTP Type = "SCTP"
TypeUDP Type = "UDP"
TypeICMP Type = "ICMP"
TypeSTARTTLS Type = "STARTTLS"
TypeTLS Type = "TLS"
TypeHTTP Type = "HTTP"
2025-11-08 00:19:13 +04:00
TypeGRPC Type = "GRPC"
2024-05-09 22:56:16 -04:00
TypeWS Type = "WEBSOCKET"
TypeSSH Type = "SSH"
TypeUNKNOWN Type = "UNKNOWN"
2021-10-23 16:47:12 -04:00
)
var (
// ErrEndpointWithNoCondition is the error with which Gatus will panic if an endpoint is configured with no conditions
ErrEndpointWithNoCondition = errors . New ( "you must specify at least one condition per endpoint" )
// ErrEndpointWithNoURL is the error with which Gatus will panic if an endpoint is configured with no url
ErrEndpointWithNoURL = errors . New ( "you must specify an url for each endpoint" )
2022-09-01 20:59:09 -04:00
// ErrUnknownEndpointType is the error with which Gatus will panic if an endpoint has an unknown type
ErrUnknownEndpointType = errors . New ( "unknown endpoint type" )
2022-09-15 21:23:14 -04:00
2022-12-06 01:37:05 -05:00
// ErrInvalidConditionFormat is the error with which Gatus will panic if a condition has an invalid format
ErrInvalidConditionFormat = errors . New ( "invalid condition format: does not match '<VALUE> <COMPARATOR> <VALUE>'" )
2022-09-15 21:23:14 -04:00
// ErrInvalidEndpointIntervalForDomainExpirationPlaceholder is the error with which Gatus will panic if an endpoint
// has both an interval smaller than 5 minutes and a condition with DomainExpirationPlaceholder.
// This is because the free whois service we are using should not be abused, especially considering the fact that
// the data takes a while to be updated.
ErrInvalidEndpointIntervalForDomainExpirationPlaceholder = errors . New ( "the minimum interval for an endpoint with a condition using the " + DomainExpirationPlaceholder + " placeholder is 300s (5m)" )
2021-10-23 16:47:12 -04:00
)
2024-04-08 21:00:40 -04:00
// Endpoint is the configuration of a service to be monitored
2021-10-23 16:47:12 -04:00
type Endpoint struct {
// Enabled defines whether to enable the monitoring of the endpoint
Enabled * bool `yaml:"enabled,omitempty"`
// Name of the endpoint. Can be anything.
Name string `yaml:"name"`
// Group the endpoint is a part of. Used for grouping multiple endpoints together on the front end.
Group string `yaml:"group,omitempty"`
// URL to send the request to
URL string `yaml:"url"`
// Method of the request made to the url of the endpoint
Method string `yaml:"method,omitempty"`
// Body of the request
Body string `yaml:"body,omitempty"`
// GraphQL is whether to wrap the body in a query param ({"query":"$body"})
GraphQL bool `yaml:"graphql,omitempty"`
// Headers of the request
Headers map [ string ] string `yaml:"headers,omitempty"`
2025-08-06 00:26:50 +08:00
// ExtraLabels are key-value pairs that can be used to metric the endpoint
ExtraLabels map [ string ] string `yaml:"extra-labels,omitempty"`
2021-10-23 16:47:12 -04:00
// Interval is the duration to wait between every status check
Interval time . Duration `yaml:"interval,omitempty"`
// Conditions used to determine the health of the endpoint
2022-06-13 19:15:30 -04:00
Conditions [] Condition `yaml:"conditions"`
2021-10-23 16:47:12 -04:00
// Alerts is the alerting configuration for the endpoint in case of failure
2021-10-24 15:03:41 -04:00
Alerts [] * alert . Alert `yaml:"alerts,omitempty"`
2021-10-23 16:47:12 -04:00
2025-02-17 12:05:13 +08:00
// MaintenanceWindow is the configuration for per-endpoint maintenance windows
MaintenanceWindows [] * maintenance . Config `yaml:"maintenance-windows,omitempty"`
2024-05-09 22:56:16 -04:00
// DNSConfig is the configuration for DNS monitoring
DNSConfig * dns . Config `yaml:"dns,omitempty"`
// SSH is the configuration for SSH monitoring
SSHConfig * sshconfig . Config `yaml:"ssh,omitempty"`
2021-10-23 16:47:12 -04:00
// ClientConfig is the configuration of the client used to communicate with the endpoint's target
2021-10-24 15:03:41 -04:00
ClientConfig * client . Config `yaml:"client,omitempty"`
2021-10-23 16:47:12 -04:00
// UIConfig is the configuration for the UI
2021-10-24 15:03:41 -04:00
UIConfig * ui . Config `yaml:"ui,omitempty"`
2021-10-23 16:47:12 -04:00
// NumberOfFailuresInARow is the number of unsuccessful evaluations in a row
2021-10-24 15:03:41 -04:00
NumberOfFailuresInARow int `yaml:"-"`
2021-10-23 16:47:12 -04:00
// NumberOfSuccessesInARow is the number of successful evaluations in a row
2021-10-24 15:03:41 -04:00
NumberOfSuccessesInARow int `yaml:"-"`
2025-08-08 03:35:44 +02:00
// LastReminderSent is the time at which the last reminder was sent for this endpoint.
LastReminderSent time . Time `yaml:"-"`
2025-09-05 15:39:12 -04:00
///////////////////////
// SUITE-ONLY FIELDS //
///////////////////////
// Store is a map of values to extract from the result and store in the suite context
// This field is only used when the endpoint is part of a suite
Store map [ string ] string `yaml:"store,omitempty"`
// AlwaysRun defines whether to execute this endpoint even if previous endpoints in the suite failed
// This field is only used when the endpoint is part of a suite
AlwaysRun bool `yaml:"always-run,omitempty"`
2021-10-23 16:47:12 -04:00
}
// IsEnabled returns whether the endpoint is enabled or not
2024-05-09 22:56:16 -04:00
func ( e * Endpoint ) IsEnabled () bool {
if e . Enabled == nil {
2021-10-23 16:47:12 -04:00
return true
}
2024-05-09 22:56:16 -04:00
return * e . Enabled
2021-10-23 16:47:12 -04:00
}
2022-05-17 09:10:45 +08:00
// Type returns the endpoint type
2024-05-09 22:56:16 -04:00
func ( e * Endpoint ) Type () Type {
2022-05-17 09:10:45 +08:00
switch {
2024-05-09 22:56:16 -04:00
case e . DNSConfig != nil :
return TypeDNS
case strings . HasPrefix ( e . URL , "tcp://" ):
return TypeTCP
case strings . HasPrefix ( e . URL , "sctp://" ):
return TypeSCTP
case strings . HasPrefix ( e . URL , "udp://" ):
return TypeUDP
case strings . HasPrefix ( e . URL , "icmp://" ):
return TypeICMP
case strings . HasPrefix ( e . URL , "starttls://" ):
return TypeSTARTTLS
case strings . HasPrefix ( e . URL , "tls://" ):
return TypeTLS
case strings . HasPrefix ( e . URL , "http://" ) || strings . HasPrefix ( e . URL , "https://" ):
return TypeHTTP
2025-11-08 00:19:13 +04:00
case strings . HasPrefix ( e . URL , "grpc://" ) || strings . HasPrefix ( e . URL , "grpcs://" ):
return TypeGRPC
2024-05-09 22:56:16 -04:00
case strings . HasPrefix ( e . URL , "ws://" ) || strings . HasPrefix ( e . URL , "wss://" ):
return TypeWS
case strings . HasPrefix ( e . URL , "ssh://" ):
return TypeSSH
2022-09-01 20:59:09 -04:00
default :
2024-05-09 22:56:16 -04:00
return TypeUNKNOWN
2022-05-17 09:10:45 +08:00
}
}
2022-09-06 21:22:02 -04:00
// ValidateAndSetDefaults validates the endpoint's configuration and sets the default value of args that have one
2024-05-09 22:56:16 -04:00
func ( e * Endpoint ) ValidateAndSetDefaults () error {
if err := validateEndpointNameGroupAndAlerts ( e . Name , e . Group , e . Alerts ); err != nil {
2024-04-08 21:00:40 -04:00
return err
}
2024-05-09 22:56:16 -04:00
if len ( e . URL ) == 0 {
2024-04-08 21:00:40 -04:00
return ErrEndpointWithNoURL
}
2024-05-09 22:56:16 -04:00
if e . ClientConfig == nil {
e . ClientConfig = client . GetDefaultConfig ()
2021-10-23 16:47:12 -04:00
} else {
2024-05-09 22:56:16 -04:00
if err := e . ClientConfig . ValidateAndSetDefaults (); err != nil {
2022-03-10 02:53:51 +01:00
return err
}
2021-10-23 16:47:12 -04:00
}
2024-05-09 22:56:16 -04:00
if e . UIConfig == nil {
e . UIConfig = ui . GetDefaultConfig ()
2022-08-11 03:05:34 +02:00
} else {
2024-05-09 22:56:16 -04:00
if err := e . UIConfig . ValidateAndSetDefaults (); err != nil {
2022-08-11 03:05:34 +02:00
return err
}
2021-10-23 16:47:12 -04:00
}
2024-05-09 22:56:16 -04:00
if e . Interval == 0 {
e . Interval = 1 * time . Minute
2021-10-23 16:47:12 -04:00
}
2024-05-09 22:56:16 -04:00
if len ( e . Method ) == 0 {
e . Method = http . MethodGet
2021-10-23 16:47:12 -04:00
}
2024-05-09 22:56:16 -04:00
if len ( e . Headers ) == 0 {
e . Headers = make ( map [ string ] string )
2021-10-23 16:47:12 -04:00
}
// Automatically add user agent header if there isn't one specified in the endpoint configuration
2026-01-24 18:49:16 -08:00
if ! hasHeader ( e . Headers , UserAgentHeader ) {
2024-05-09 22:56:16 -04:00
e . Headers [ UserAgentHeader ] = GatusUserAgent
2021-10-23 16:47:12 -04:00
}
// Automatically add "Content-Type: application/json" header if there's no Content-Type set
// and endpoint.GraphQL is set to true
2026-01-24 18:49:16 -08:00
if ! hasHeader ( e . Headers , ContentTypeHeader ) && e . GraphQL {
2024-05-09 22:56:16 -04:00
e . Headers [ ContentTypeHeader ] = "application/json"
2021-10-23 16:47:12 -04:00
}
2024-05-09 22:56:16 -04:00
if len ( e . Conditions ) == 0 {
2021-10-23 16:47:12 -04:00
return ErrEndpointWithNoCondition
}
2024-05-09 22:56:16 -04:00
for _ , c := range e . Conditions {
if e . Interval < 5 * time . Minute && c . hasDomainExpirationPlaceholder () {
2022-12-06 01:37:05 -05:00
return ErrInvalidEndpointIntervalForDomainExpirationPlaceholder
}
if err := c . Validate (); err != nil {
return fmt . Errorf ( "%v: %w" , ErrInvalidConditionFormat , err )
2022-09-15 21:23:14 -04:00
}
}
2024-05-09 22:56:16 -04:00
if e . DNSConfig != nil {
return e . DNSConfig . ValidateAndSetDefault ()
2021-10-23 16:47:12 -04:00
}
2024-05-09 22:56:16 -04:00
if e . SSHConfig != nil {
return e . SSHConfig . Validate ()
2024-04-08 21:00:40 -04:00
}
2024-05-09 22:56:16 -04:00
if e . Type () == TypeUNKNOWN {
2022-09-01 20:59:09 -04:00
return ErrUnknownEndpointType
}
2025-02-17 12:05:13 +08:00
for _ , maintenanceWindow := range e . MaintenanceWindows {
if err := maintenanceWindow . ValidateAndSetDefaults (); err != nil {
return err
}
}
2021-10-23 16:47:12 -04:00
// Make sure that the request can be created
2025-07-19 19:24:03 -06:00
_ , err := http . NewRequest ( e . Method , e . URL , bytes . NewBuffer ([] byte ( e . getParsedBody ())))
2021-10-23 16:47:12 -04:00
if err != nil {
return err
}
return nil
}
2021-12-12 16:28:24 -05:00
// DisplayName returns an identifier made up of the Name and, if not empty, the Group.
2024-05-09 22:56:16 -04:00
func ( e * Endpoint ) DisplayName () string {
if len ( e . Group ) > 0 {
return e . Group + "/" + e . Name
2021-12-12 16:28:24 -05:00
}
2024-05-09 22:56:16 -04:00
return e . Name
2021-12-12 16:28:24 -05:00
}
2021-10-23 16:47:12 -04:00
// Key returns the unique key for the Endpoint
2024-05-09 22:56:16 -04:00
func ( e * Endpoint ) Key () string {
2025-09-05 15:39:12 -04:00
return key . ConvertGroupAndNameToKey ( e . Group , e . Name )
2021-10-23 16:47:12 -04:00
}
2024-04-08 21:00:40 -04:00
// Close HTTP connections between watchdog and endpoints to avoid dangling socket file descriptors
// on configuration reload.
// More context on https://github.com/TwiN/gatus/issues/536
2024-05-09 22:56:16 -04:00
func ( e * Endpoint ) Close () {
if e . Type () == TypeHTTP {
client . GetHTTPClient ( e . ClientConfig ). CloseIdleConnections ()
2024-04-08 21:00:40 -04:00
}
}
2021-10-23 16:47:12 -04:00
// EvaluateHealth sends a request to the endpoint's URL and evaluates the conditions of the endpoint.
2024-05-09 22:56:16 -04:00
func ( e * Endpoint ) EvaluateHealth () * Result {
2025-09-05 15:39:12 -04:00
return e . EvaluateHealthWithContext ( nil )
}
// EvaluateHealthWithContext sends a request to the endpoint's URL with context support and evaluates the conditions
func ( e * Endpoint ) EvaluateHealthWithContext ( context * gontext . Gontext ) * Result {
2021-10-23 16:47:12 -04:00
result := & Result { Success : true , Errors : [] string {}}
2025-09-05 15:39:12 -04:00
// Preprocess the endpoint with context if provided
processedEndpoint := e
if context != nil {
processedEndpoint = e . preprocessWithContext ( result , context )
}
2022-09-06 21:22:02 -04:00
// Parse or extract hostname from URL
2025-09-05 15:39:12 -04:00
if processedEndpoint . DNSConfig != nil {
result . Hostname = strings . TrimSuffix ( processedEndpoint . URL , ":53" )
} else if processedEndpoint . Type () == TypeICMP {
2025-03-26 18:46:46 -04:00
// To handle IPv6 addresses, we need to handle the hostname differently here. This is to avoid, for instance,
// "1111:2222:3333::4444" being displayed as "1111:2222:3333:" because :4444 would be interpreted as a port.
2025-09-05 15:39:12 -04:00
result . Hostname = strings . TrimPrefix ( processedEndpoint . URL , "icmp://" )
2022-09-06 21:22:02 -04:00
} else {
2025-09-05 15:39:12 -04:00
urlObject , err := url . Parse ( processedEndpoint . URL )
2022-09-06 21:22:02 -04:00
if err != nil {
result . AddError ( err . Error ())
} else {
result . Hostname = urlObject . Hostname ()
2025-03-20 16:31:14 -04:00
result . port = urlObject . Port ()
2022-09-06 21:22:02 -04:00
}
}
// Retrieve IP if necessary
2025-09-05 15:39:12 -04:00
if processedEndpoint . needsToRetrieveIP () {
processedEndpoint . getIP ( result )
2022-09-06 21:22:02 -04:00
}
2022-11-15 21:35:22 -05:00
// Retrieve domain expiration if necessary
2025-09-05 15:39:12 -04:00
if processedEndpoint . needsToRetrieveDomainExpiration () && len ( result . Hostname ) > 0 {
2022-11-15 21:35:22 -05:00
var err error
if result . DomainExpiration , err = client . GetDomainExpiration ( result . Hostname ); err != nil {
result . AddError ( err . Error ())
}
}
// Call the endpoint (if there's no errors)
2021-10-23 16:47:12 -04:00
if len ( result . Errors ) == 0 {
2025-09-05 15:39:12 -04:00
processedEndpoint . call ( result )
2021-10-23 16:47:12 -04:00
} else {
result . Success = false
}
2022-11-15 21:35:22 -05:00
// Evaluate the conditions
2025-09-05 15:39:12 -04:00
for _ , condition := range processedEndpoint . Conditions {
2026-01-12 00:36:23 -03:00
success := condition . evaluate ( result , processedEndpoint . UIConfig . DontResolveFailedConditions , processedEndpoint . UIConfig . ResolveSuccessfulConditions , context )
2021-10-23 16:47:12 -04:00
if ! success {
result . Success = false
}
}
result . Timestamp = time . Now ()
// Clean up parameters that we don't need to keep in the results
2025-09-05 15:39:12 -04:00
if processedEndpoint . UIConfig . HideURL {
2022-06-17 02:53:03 +05:00
for errIdx , errorString := range result . Errors {
2025-09-05 15:39:12 -04:00
result . Errors [ errIdx ] = strings . ReplaceAll ( errorString , processedEndpoint . URL , "<redacted>" )
2022-06-17 02:53:03 +05:00
}
}
2025-09-05 15:39:12 -04:00
if processedEndpoint . UIConfig . HideHostname {
2022-03-16 05:47:57 +05:30
for errIdx , errorString := range result . Errors {
2022-03-15 20:51:59 -04:00
result . Errors [ errIdx ] = strings . ReplaceAll ( errorString , result . Hostname , "<redacted>" )
2022-03-16 05:47:57 +05:30
}
2025-03-20 16:31:14 -04:00
result . Hostname = "" // remove it from the result so it doesn't get exposed
}
2025-09-05 15:39:12 -04:00
if processedEndpoint . UIConfig . HidePort && len ( result . port ) > 0 {
2025-03-20 16:31:14 -04:00
for errIdx , errorString := range result . Errors {
result . Errors [ errIdx ] = strings . ReplaceAll ( errorString , result . port , "<redacted>" )
}
result . port = ""
2021-10-23 16:47:12 -04:00
}
2025-10-22 13:13:53 -04:00
if processedEndpoint . UIConfig . HideErrors {
result . Errors = nil
}
2025-09-05 15:39:12 -04:00
if processedEndpoint . UIConfig . HideConditions {
2024-04-18 20:57:07 -04:00
result . ConditionResults = nil
}
2021-10-23 16:47:12 -04:00
return result
}
2025-09-05 15:39:12 -04:00
// preprocessWithContext creates a copy of the endpoint with context placeholders replaced
func ( e * Endpoint ) preprocessWithContext ( result * Result , context * gontext . Gontext ) * Endpoint {
// Create a deep copy of the endpoint
processed := & Endpoint {}
* processed = * e
var err error
// Replace context placeholders in URL
if processed . URL , err = replaceContextPlaceholders ( e . URL , context ); err != nil {
result . AddError ( err . Error ())
}
// Replace context placeholders in Body
if processed . Body , err = replaceContextPlaceholders ( e . Body , context ); err != nil {
result . AddError ( err . Error ())
}
// Replace context placeholders in Headers
if e . Headers != nil {
processed . Headers = make ( map [ string ] string )
for k , v := range e . Headers {
if processed . Headers [ k ], err = replaceContextPlaceholders ( v , context ); err != nil {
result . AddError ( err . Error ())
}
}
}
return processed
}
// replaceContextPlaceholders replaces [CONTEXT].path placeholders with actual values
func replaceContextPlaceholders ( input string , ctx * gontext . Gontext ) ( string , error ) {
if ctx == nil {
return input , nil
}
var contextErrors [] string
2025-09-19 12:09:18 -04:00
contextRegex := regexp . MustCompile ( `\[CONTEXT\]\.[\w\.\-]+` )
2025-09-05 15:39:12 -04:00
result := contextRegex . ReplaceAllStringFunc ( input , func ( match string ) string {
// Extract the path after [CONTEXT].
path := strings . TrimPrefix ( match , "[CONTEXT]." )
value , err := ctx . Get ( path )
if err != nil {
contextErrors = append ( contextErrors , fmt . Sprintf ( "path '%s' not found" , path ))
return match // Keep placeholder for error reporting
}
return fmt . Sprintf ( "%v" , value )
})
if len ( contextErrors ) > 0 {
return result , fmt . Errorf ( "context placeholder resolution failed: %s" , strings . Join ( contextErrors , ", " ))
}
return result , nil
}
2025-07-19 19:24:03 -06:00
func ( e * Endpoint ) getParsedBody () string {
body := e . Body
body = strings . ReplaceAll ( body , "[ENDPOINT_NAME]" , e . Name )
body = strings . ReplaceAll ( body , "[ENDPOINT_GROUP]" , e . Group )
body = strings . ReplaceAll ( body , "[ENDPOINT_URL]" , e . URL )
randRegex , err := regexp . Compile ( `\[RANDOM_STRING_\d+\]` )
if err == nil {
body = randRegex . ReplaceAllStringFunc ( body , func ( match string ) string {
n , _ := strconv . Atoi ( match [ 15 : len ( match ) - 1 ])
2025-08-11 09:36:55 -04:00
if n > 8192 {
n = 8192 // Limit the length of the random string to 8192 bytes to avoid excessive memory usage
}
2025-07-19 19:24:03 -06:00
const availableCharacterBytes = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789"
b := make ([] byte , n )
for i := range b {
b [ i ] = availableCharacterBytes [ rand . Intn ( len ( availableCharacterBytes ))]
}
return string ( b )
})
}
return body
}
2024-05-09 22:56:16 -04:00
func ( e * Endpoint ) getIP ( result * Result ) {
2022-11-15 21:35:22 -05:00
if ips , err := net . LookupIP ( result . Hostname ); err != nil {
2021-10-23 16:47:12 -04:00
result . AddError ( err . Error ())
return
2022-09-06 21:22:02 -04:00
} else {
2022-11-15 21:35:22 -05:00
result . IP = ips [ 0 ]. String ()
2022-09-06 21:22:02 -04:00
}
}
2024-05-09 22:56:16 -04:00
func ( e * Endpoint ) call ( result * Result ) {
2021-10-23 16:47:12 -04:00
var request * http . Request
var response * http . Response
var err error
var certificate * x509 . Certificate
2024-05-09 22:56:16 -04:00
endpointType := e . Type ()
if endpointType == TypeHTTP {
request = e . buildHTTPRequest ()
2021-10-23 16:47:12 -04:00
}
startTime := time . Now ()
2024-05-09 22:56:16 -04:00
if endpointType == TypeDNS {
result . Connected , result . DNSRCode , result . Body , err = client . QueryDNS ( e . DNSConfig . QueryType , e . DNSConfig . QueryName , e . URL )
if err != nil {
result . AddError ( err . Error ())
return
}
2021-10-23 16:47:12 -04:00
result . Duration = time . Since ( startTime )
2024-05-09 22:56:16 -04:00
} else if endpointType == TypeSTARTTLS || endpointType == TypeTLS {
if endpointType == TypeSTARTTLS {
result . Connected , certificate , err = client . CanPerformStartTLS ( strings . TrimPrefix ( e . URL , "starttls://" ), e . ClientConfig )
2021-10-23 16:47:12 -04:00
} else {
2025-07-19 19:24:03 -06:00
result . Connected , result . Body , certificate , err = client . CanPerformTLS ( strings . TrimPrefix ( e . URL , "tls://" ), e . getParsedBody (), e . ClientConfig )
2021-10-23 16:47:12 -04:00
}
if err != nil {
result . AddError ( err . Error ())
return
}
result . Duration = time . Since ( startTime )
result . CertificateExpiration = time . Until ( certificate . NotAfter )
2024-05-09 22:56:16 -04:00
} else if endpointType == TypeTCP {
2025-07-19 19:24:03 -06:00
result . Connected , result . Body = client . CanCreateNetworkConnection ( "tcp" , strings . TrimPrefix ( e . URL , "tcp://" ), e . getParsedBody (), e . ClientConfig )
2021-10-23 16:47:12 -04:00
result . Duration = time . Since ( startTime )
2024-05-09 22:56:16 -04:00
} else if endpointType == TypeUDP {
2025-07-19 19:24:03 -06:00
result . Connected , result . Body = client . CanCreateNetworkConnection ( "udp" , strings . TrimPrefix ( e . URL , "udp://" ), e . getParsedBody (), e . ClientConfig )
2022-11-10 08:22:13 +08:00
result . Duration = time . Since ( startTime )
2024-05-09 22:56:16 -04:00
} else if endpointType == TypeSCTP {
result . Connected = client . CanCreateSCTPConnection ( strings . TrimPrefix ( e . URL , "sctp://" ), e . ClientConfig )
2022-11-10 08:22:13 +08:00
result . Duration = time . Since ( startTime )
2024-05-09 22:56:16 -04:00
} else if endpointType == TypeICMP {
result . Connected , result . Duration = client . Ping ( strings . TrimPrefix ( e . URL , "icmp://" ), e . ClientConfig )
} else if endpointType == TypeWS {
2025-08-02 21:06:46 +03:00
wsHeaders := map [ string ] string {}
if e . Headers != nil {
2026-02-09 01:08:59 +01:00
maps . Copy ( wsHeaders , e . Headers )
2025-08-02 21:06:46 +03:00
}
2026-01-24 18:49:16 -08:00
if ! hasHeader ( wsHeaders , UserAgentHeader ) {
wsHeaders [ UserAgentHeader ] = GatusUserAgent
2025-08-02 21:06:46 +03:00
}
result . Connected , result . Body , err = client . QueryWebSocket ( e . URL , e . getParsedBody (), wsHeaders , e . ClientConfig )
2023-08-16 22:48:57 -03:00
if err != nil {
result . AddError ( err . Error ())
return
}
2023-09-28 18:35:18 -04:00
result . Duration = time . Since ( startTime )
2024-05-09 22:56:16 -04:00
} else if endpointType == TypeSSH {
2025-11-20 03:06:36 +05:30
// If there's no username, password or private key specified, attempt to validate just the SSH banner
if e . SSHConfig == nil || ( len ( e . SSHConfig . Username ) == 0 && len ( e . SSHConfig . Password ) == 0 && len ( e . SSHConfig . PrivateKey ) == 0 ) {
2025-08-06 00:26:50 +08:00
result . Connected , result . HTTPStatus , err = client . CheckSSHBanner ( strings . TrimPrefix ( e . URL , "ssh://" ), e . ClientConfig )
2025-01-19 23:22:41 +02:00
if err != nil {
result . AddError ( err . Error ())
return
}
result . Success = result . Connected
result . Duration = time . Since ( startTime )
return
}
2023-09-23 14:37:24 -03:00
var cli * ssh . Client
2025-11-20 03:06:36 +05:30
result . Connected , cli , err = client . CanCreateSSHConnection ( strings . TrimPrefix ( e . URL , "ssh://" ), e . SSHConfig . Username , e . SSHConfig . Password , e . SSHConfig . PrivateKey , e . ClientConfig )
2023-09-23 14:37:24 -03:00
if err != nil {
result . AddError ( err . Error ())
return
}
2025-10-04 10:52:34 +08:00
var output [] byte
result . Success , result . HTTPStatus , output , err = client . ExecuteSSHCommand ( cli , e . getParsedBody (), e . ClientConfig )
2023-09-23 14:37:24 -03:00
if err != nil {
result . AddError ( err . Error ())
return
}
2025-10-04 10:52:34 +08:00
// Only store the output in result.Body if there's a condition that uses the BodyPlaceholder
if e . needsToReadBody () {
result . Body = output
}
2023-09-23 14:37:24 -03:00
result . Duration = time . Since ( startTime )
2025-11-08 00:19:13 +04:00
} else if endpointType == TypeGRPC {
useTLS := strings . HasPrefix ( e . URL , "grpcs://" )
address := strings . TrimPrefix ( strings . TrimPrefix ( e . URL , "grpcs://" ), "grpc://" )
connected , status , err , duration := client . PerformGRPCHealthCheck ( address , useTLS , e . ClientConfig )
if err != nil {
result . AddError ( err . Error ())
return
}
result . Connected = connected
result . Duration = duration
if e . needsToReadBody () {
result . Body = [] byte ( fmt . Sprintf ( "{\"status\":\"%s\"}" , status ))
}
2021-10-23 16:47:12 -04:00
} else {
2024-05-09 22:56:16 -04:00
response , err = client . GetHTTPClient ( e . ClientConfig ). Do ( request )
2021-10-23 16:47:12 -04:00
result . Duration = time . Since ( startTime )
if err != nil {
result . AddError ( err . Error ())
return
}
defer response . Body . Close ()
if response . TLS != nil && len ( response . TLS . PeerCertificates ) > 0 {
certificate = response . TLS . PeerCertificates [ 0 ]
result . CertificateExpiration = time . Until ( certificate . NotAfter )
}
result . HTTPStatus = response . StatusCode
result . Connected = response . StatusCode > 0
2023-03-14 20:02:31 -04:00
// Only read the Body if there's a condition that uses the BodyPlaceholder
2024-05-09 22:56:16 -04:00
if e . needsToReadBody () {
2023-03-14 20:02:31 -04:00
result . Body , err = io . ReadAll ( response . Body )
2021-10-23 16:47:12 -04:00
if err != nil {
2022-09-06 21:22:02 -04:00
result . AddError ( "error reading response body:" + err . Error ())
2021-10-23 16:47:12 -04:00
}
}
}
}
2024-05-09 22:56:16 -04:00
func ( e * Endpoint ) buildHTTPRequest () * http . Request {
2021-10-23 16:47:12 -04:00
var bodyBuffer * bytes . Buffer
2024-05-09 22:56:16 -04:00
if e . GraphQL {
2021-10-23 16:47:12 -04:00
graphQlBody := map [ string ] string {
2025-07-19 19:24:03 -06:00
"query" : e . getParsedBody (),
2021-10-23 16:47:12 -04:00
}
body , _ := json . Marshal ( graphQlBody )
bodyBuffer = bytes . NewBuffer ( body )
} else {
2025-07-19 19:24:03 -06:00
bodyBuffer = bytes . NewBuffer ([] byte ( e . getParsedBody ()))
2021-10-23 16:47:12 -04:00
}
2024-05-09 22:56:16 -04:00
request , _ := http . NewRequest ( e . Method , e . URL , bodyBuffer )
for k , v := range e . Headers {
2021-10-23 16:47:12 -04:00
request . Header . Set ( k , v )
2026-01-24 18:49:16 -08:00
if strings . EqualFold ( k , HostHeader ) {
2021-10-23 16:47:12 -04:00
request . Host = v
}
}
return request
}
2025-09-21 13:15:59 -04:00
// needsToReadBody checks if there's any condition or store mapping that requires the response Body to be read
2024-05-09 22:56:16 -04:00
func ( e * Endpoint ) needsToReadBody () bool {
for _ , condition := range e . Conditions {
2021-10-23 16:47:12 -04:00
if condition . hasBodyPlaceholder () {
return true
}
}
2025-09-21 13:15:59 -04:00
// Check store values for body placeholders
if e . Store != nil {
for _ , value := range e . Store {
if strings . Contains ( value , BodyPlaceholder ) {
return true
}
}
}
2021-10-23 16:47:12 -04:00
return false
}
2022-09-06 21:22:02 -04:00
// needsToRetrieveDomainExpiration checks if there's any condition that requires a whois query to be performed
2024-05-09 22:56:16 -04:00
func ( e * Endpoint ) needsToRetrieveDomainExpiration () bool {
for _ , condition := range e . Conditions {
2022-09-06 21:22:02 -04:00
if condition . hasDomainExpirationPlaceholder () {
return true
}
}
return false
}
// needsToRetrieveIP checks if there's any condition that requires an IP lookup
2024-05-09 22:56:16 -04:00
func ( e * Endpoint ) needsToRetrieveIP () bool {
for _ , condition := range e . Conditions {
2022-09-06 21:22:02 -04:00
if condition . hasIPPlaceholder () {
return true
}
}
return false
}
2026-01-24 18:49:16 -08:00
// hasHeader checks if a header exists in the map using a case-insensitive lookup
func hasHeader ( headers map [ string ] string , name string ) bool {
for k := range headers {
if strings . EqualFold ( k , name ) {
return true
}
}
return false
}