Add public monitoring features and CI updates

- Add status pages, incidents, badges, maintenance, bulk ops, and metrics - Add Docker packaging, env example, and frontend routes - Refresh GitHub workflows and project metadata
2026-06-03 21:02:56 +00:00 · 2026-04-27 11:10:18 +02:00
parent 363d708e91
commit 8011d487f1
101 changed files with 16126 additions and 2028 deletions
@@ -4,6 +4,8 @@ import (
 	"context"
 	"fmt"
 	"log"
+	"net"
+	"strings"
 	"sync"
 	"time"

@@ -13,13 +15,17 @@ import (
 	"github.com/pocketbase/pocketbase/core"
 )

+// AlertCallback is a function that sends alerts
+type AlertCallback func(userID, title, message, link, linkText string)
+
 // Scheduler manages periodic domain checks for expiry and SSL
 type Scheduler struct {
-	app      core.App
-	whois    *whois.LookupService
-	ticker   *time.Ticker
-	stopChan chan struct{}
-	wg       sync.WaitGroup
+	app           core.App
+	whois         *whois.LookupService
+	ticker        *time.Ticker
+	stopChan      chan struct{}
+	wg            sync.WaitGroup
+	alertCallback AlertCallback
 }

 // NewScheduler creates a new domain scheduler
@@ -31,6 +37,11 @@ func NewScheduler(app core.App) *Scheduler {
 	}
 }

+// SetAlertCallback sets the callback function for sending alerts
+func (s *Scheduler) SetAlertCallback(callback AlertCallback) {
+	s.alertCallback = callback
+}
+
 // Start begins the domain check scheduler
 func (s *Scheduler) Start() {
 	log.Println("[domain-scheduler] Starting domain scheduler")
@@ -89,9 +100,10 @@ func (s *Scheduler) checkDomains() {
 // checkDomain checks a single domain
 func (s *Scheduler) checkDomain(record *core.Record) {
 	domainName := record.GetString("domain_name")
+
 	userID := record.GetString("user")

-	log.Printf("[domain-scheduler] Checking domain: %s", domainName)
+	log.Printf("[domain-scheduler] Checking domain: %s for user %s", domainName, userID)

 	// Perform WHOIS and DNS lookup
 	ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
@@ -106,32 +118,94 @@ func (s *Scheduler) checkDomain(record *core.Record) {
 	// Track changes
 	history := s.trackChanges(record, newData)

-	// Update record
-	record.Set("expiry_date", newData.ExpiryDate)
-	record.Set("creation_date", newData.CreationDate)
-	record.Set("updated_date", newData.UpdatedDate)
-	record.Set("registrar_name", newData.RegistrarName)
-	record.Set("registrar_id", newData.RegistrarID)
-	record.Set("registrar_url", newData.RegistrarURL)
+	// Update record (only overwrite if new data is present to preserve valid data on partial lookups)
+	if newData.ExpiryDate != nil {
+		record.Set("expiry_date", *newData.ExpiryDate)
+	}
+	if newData.CreationDate != nil {
+		record.Set("creation_date", *newData.CreationDate)
+	}
+	if newData.UpdatedDate != nil {
+		record.Set("updated_date", *newData.UpdatedDate)
+	}
+	if newData.RegistrarName != "" {
+		record.Set("registrar_name", newData.RegistrarName)
+	}
+	if newData.RegistrarID != "" {
+		record.Set("registrar_id", newData.RegistrarID)
+	}
+	if newData.RegistrarURL != "" {
+		record.Set("registrar_url", newData.RegistrarURL)
+	}
 	record.Set("dnssec", newData.DNSSEC)
-	record.Set("name_servers", newData.NameServers)
-	record.Set("mx_records", newData.MXRecords)
-	record.Set("txt_records", newData.TXTRecords)
-	record.Set("ipv4_addresses", newData.IPv4Addresses)
-	record.Set("ipv6_addresses", newData.IPv6Addresses)
-	record.Set("ssl_issuer", newData.SSLIssuer)
-	record.Set("ssl_valid_to", newData.SSLValidTo)
+	if len(newData.NameServers) > 0 {
+		record.Set("name_servers", newData.NameServers)
+	}
+	if len(newData.MXRecords) > 0 {
+		record.Set("mx_records", newData.MXRecords)
+	}
+	if len(newData.TXTRecords) > 0 {
+		record.Set("txt_records", newData.TXTRecords)
+	}
+	if len(newData.IPv4Addresses) > 0 {
+		record.Set("ipv4_addresses", newData.IPv4Addresses)
+	}
+	if len(newData.IPv6Addresses) > 0 {
+		record.Set("ipv6_addresses", newData.IPv6Addresses)
+	}
+
+	// Update SSL info - only overwrite if new data is present to avoid losing valid SSL data on lookup failure
+	if newData.SSLIssuer != "" {
+		record.Set("ssl_issuer", newData.SSLIssuer)
+	}
+	if newData.SSLIssuerCountry != "" {
+		record.Set("ssl_issuer_country", newData.SSLIssuerCountry)
+	}
+	if newData.SSLSubject != "" {
+		record.Set("ssl_subject", newData.SSLSubject)
+	}
+	if newData.SSLValidFrom != nil && !newData.SSLValidFrom.IsZero() {
+		record.Set("ssl_valid_from", *newData.SSLValidFrom)
+	}
+	if newData.SSLValidTo != nil && !newData.SSLValidTo.IsZero() {
+		record.Set("ssl_valid_to", *newData.SSLValidTo)
+	}
+	if newData.SSLFingerprint != "" {
+		record.Set("ssl_fingerprint", newData.SSLFingerprint)
+	}
+	if newData.SSLKeySize > 0 {
+		record.Set("ssl_key_size", newData.SSLKeySize)
+	}
+	if newData.SSLSignatureAlgo != "" {
+		record.Set("ssl_signature_algo", newData.SSLSignatureAlgo)
+	}
 	record.Set("host_country", newData.HostCountry)
 	record.Set("host_isp", newData.HostISP)
 	record.Set("last_checked", time.Now())

-	// Update status
-	status := domain.DomainStatusActive
-	if newData.ExpiryDate != nil {
-		if newData.IsExpired() {
+	// Update status - fallback to existing record expiry if new lookup didn't return one
+	status := record.GetString("status")
+	if status == "" {
+		status = domain.DomainStatusActive
+	}
+
+	expiryDate := newData.ExpiryDate
+	if expiryDate == nil {
+		existingExpiry := record.GetDateTime("expiry_date")
+		if !existingExpiry.IsZero() {
+			t := existingExpiry.Time()
+			expiryDate = &t
+		}
+	}
+
+	if expiryDate != nil {
+		daysUntil := int(time.Until(*expiryDate).Hours() / 24)
+		if daysUntil < 0 {
 			status = domain.DomainStatusExpired
-		} else if newData.IsExpiring() {
+		} else if daysUntil <= 30 {
 			status = domain.DomainStatusExpiring
+		} else {
+			status = domain.DomainStatusActive
 		}
 	} else {
 		status = domain.DomainStatusUnknown
@@ -161,9 +235,67 @@ func (s *Scheduler) checkDomain(record *core.Record) {
 		}
 	}

+	// Discover and save subdomains
+	s.discoverSubdomains(record, domainName, userID)
+
 	log.Printf("[domain-scheduler] Updated domain: %s (status: %s)", domainName, status)
 }

+// discoverSubdomains discovers and saves subdomains for a domain
+func (s *Scheduler) discoverSubdomains(record *core.Record, domainName, userID string) {
+	// Common subdomains to check
+	commonSubdomains := []string{
+		"www", "mail", "ftp", "api", "blog", "shop", "admin", "app", "cdn",
+		"static", "dev", "staging", "test", "demo", "docs", "support", "help",
+		"status", "monitor", "grafana", "prometheus", "db", "cache", "redis",
+		"queue", "worker", "backup", "media", "assets", "download", "upload",
+		"git", "gitlab", "github", "jenkins", "ci", "cd", "vpn", "ssh",
+		"smtp", "imap", "mx", "webmail", "email", "analytics", "stats",
+		"search", "login", "auth", "sso", "oauth", "account", "user",
+	}
+
+	// Get existing subdomains to avoid duplicates
+	existing, _ := s.app.FindAllRecords("subdomains",
+		dbx.NewExp("domain = {:domain}", dbx.Params{"domain": record.Id}),
+	)
+	existingMap := make(map[string]bool)
+	for _, sub := range existing {
+		existingMap[sub.GetString("subdomain_name")] = true
+	}
+
+	collection, err := s.app.FindCollectionByNameOrId("subdomains")
+	if err != nil {
+		return
+	}
+
+	for _, sub := range commonSubdomains {
+		if existingMap[sub] {
+			continue
+		}
+
+		fullDomain := sub + "." + domainName
+		ips, err := net.LookupHost(fullDomain)
+		if err != nil || len(ips) == 0 {
+			continue
+		}
+
+		// Found a valid subdomain
+		subRecord := core.NewRecord(collection)
+		subRecord.Set("domain", record.Id)
+		subRecord.Set("subdomain_name", sub)
+		subRecord.Set("status", "active")
+		subRecord.Set("ip_addresses", strings.Join(ips, ","))
+		subRecord.Set("last_checked", time.Now())
+		subRecord.Set("user", userID)
+
+		if err := s.app.Save(subRecord); err != nil {
+			log.Printf("[domain-scheduler] Failed to save subdomain %s: %v", fullDomain, err)
+		} else {
+			log.Printf("[domain-scheduler] Discovered subdomain: %s", fullDomain)
+		}
+	}
+}
+
 // trackChanges compares old and new data and returns history entries
 func (s *Scheduler) trackChanges(oldRecord *core.Record, newData *domain.Domain) []domain.DomainHistory {
 	var history []domain.DomainHistory
@@ -245,6 +377,7 @@ func (s *Scheduler) saveHistory(h domain.DomainHistory, domainID, userID string)
 // triggerNotification sends notification for domain events
 func (s *Scheduler) triggerNotification(record *core.Record, status string) {
 	domainName := record.GetString("domain_name")
+	userID := record.GetString("user")
 	daysUntil := 0

 	if expiry := record.GetDateTime("expiry_date"); !expiry.IsZero() {
@@ -263,20 +396,30 @@ func (s *Scheduler) triggerNotification(record *core.Record, status string) {

 	log.Printf("[domain-scheduler] %s: %s", title, body)

-	// TODO: Integrate with notification system
-	// This would call the notification dispatcher similar to monitor alerts
+	// Send notification via alert callback if available
+	if s.alertCallback != nil && userID != "" {
+		link := fmt.Sprintf("/domain/%s", record.Id)
+		linkText := "View Domain"
+		s.alertCallback(userID, title, body, link, linkText)
+	}
 }

 // triggerSSLNotification sends notification for SSL expiry
 func (s *Scheduler) triggerSSLNotification(record *core.Record, daysUntil int) {
 	domainName := record.GetString("domain_name")
+	userID := record.GetString("user")

 	title := fmt.Sprintf("SSL Certificate Expiring: %s", domainName)
 	body := fmt.Sprintf("The SSL certificate for %s expires in %d days.", domainName, daysUntil)

 	log.Printf("[domain-scheduler] %s: %s", title, body)

-	// TODO: Integrate with notification system
+	// Send notification via alert callback if available
+	if s.alertCallback != nil && userID != "" {
+		link := fmt.Sprintf("/domain/%s", record.Id)
+		linkText := "View Domain"
+		s.alertCallback(userID, title, body, link, linkText)
+	}
 }

 // RefreshDomain manually refreshes a single domain