Update main.go

Author: hhftechnology

main.go

@@ -11,7 +11,6 @@ import (
 	"github.com/cloudflare/cloudflare-go"
 	"github.com/go-resty/resty/v2"
 	"github.com/traefik/traefik/v3/pkg/muxer/http"
-
 	log "github.com/sirupsen/logrus"
 )
 
@@ -20,11 +19,9 @@ func init() {
 		DisableColors: true,
 		FullTimestamp: true,
 	})
-	// Set log level based on environment variable or default to info
-	logLevel := os.Getenv("LOG_LEVEL")
-	if logLevel != "" {
-		level, err := log.ParseLevel(logLevel)
-		if err == nil {
+	// Set log level from environment variable, default to info
+	if logLevel := os.Getenv("LOG_LEVEL"); logLevel != "" {
+		if level, err := log.ParseLevel(logLevel); err == nil {
 			log.SetLevel(level)
 		}
 	}
@@ -40,20 +37,21 @@ func main() {
 		"TRAEFIK_SERVICE_ENDPOINT",
 		"TRAEFIK_API_ENDPOINT",
 	}
-
 	for _, envVar := range requiredEnvVars {
 		if os.Getenv(envVar) == "" {
 			log.Fatalf("Required environment variable %s is not set", envVar)
 		}
 	}
 
+	// Initialize Cloudflare client
 	cf, err := cloudflare.NewWithAPIToken(os.Getenv("CLOUDFLARE_API_TOKEN"))
 	if err != nil {
-		log.Fatal(err)
+		log.Fatalf("Failed to initialize Cloudflare client: %v", err)
 	}
 
 	ctx := context.Background()
 
+	// Initialize HTTP client for Traefik API
 	client := resty.New().
 		SetBaseURL(os.Getenv("TRAEFIK_API_ENDPOINT")).
 		SetTimeout(10 * time.Second).
@@ -63,80 +61,78 @@ func main() {
 	var cache []Router
 	for poll := range pollCh {
 		if poll.Err != nil {
-			log.Fatal(poll.Err)
+			log.Errorf("Polling error: %v", poll.Err)
+			continue // Continue instead of fatal to keep the loop running
 		}
 
-		// skip if no changes to traefik routers
+		// Skip if no changes detected
 		if reflect.DeepEqual(cache, poll.Routers) {
 			continue
 		}
 
-		log.Info("changes detected")
-
-		// update the cache
+		log.Info("Traefik router changes detected")
 		cache = poll.Routers
 
-		// Group routes by domain to avoid duplicates
+		// Group routes by domain, avoiding duplicates
 		domainRoutes := make(map[string]bool)
-
 		for _, r := range poll.Routers {
-			// Only enabled routes
-			if r.Status != "enabled" {
-				log.Debugf("Skipping disabled route: %s", r.Rule)
+			// Skip disabled or internal routers
+			if r.Status != "enabled" || r.Provider == "internal" {
+				log.Debugf("Skipping route: %s (status: %s, provider: %s)", r.Rule, r.Status, r.Provider)
 				continue
 			}
 
-			// Handle both HTTP and HTTPS routes
-			// We want to include all routes, including those with TLS configured
-			if os.Getenv("TRAEFIK_ENTRYPOINT") != "" {
-				// If TRAEFIK_ENTRYPOINT is specified, only use routes with that entrypoint
-				if !contains(r.EntryPoints, os.Getenv("TRAEFIK_ENTRYPOINT")) {
-					log.Debugf("Skipping route with different entrypoint: %s", r.Rule)
+			// Filter by entrypoint if specified
+			if entrypoint := os.Getenv("TRAEFIK_ENTRYPOINT"); entrypoint != "" {
+				if !contains(r.EntryPoints, entrypoint) {
+					log.Debugf("Skipping route with mismatched entrypoint: %s", r.Rule)
 					continue
 				}
 			}
 
+			// Parse domains from the rule
 			domains, err := http.ParseDomains(r.Rule)
 			if err != nil {
 				log.Errorf("Failed to parse domains from rule %s: %v", r.Rule, err)
 				continue
 			}
 
-			// Add each domain only once
+			// Log and add unique domains
 			for _, domain := range domains {
-				if _, exists := domainRoutes[domain]; !exists {
+				if !domainRoutes[domain] {
 					domainRoutes[domain] = true
+					log.Debugf("Processing domain: %s from rule: %s", domain, r.Rule)
 				}
 			}
 		}
 
-		// Create tunnel configuration with unique domains
+		// Build Cloudflare tunnel ingress rules
 		ingress := []cloudflare.UnvalidatedIngressRule{}
 		for domain := range domainRoutes {
 			log.WithFields(log.Fields{
 				"domain":  domain,
 				"service": os.Getenv("TRAEFIK_SERVICE_ENDPOINT"),
-			}).Info("upserting tunnel")
+			}).Info("Adding tunnel ingress rule")
 
-			// Create a single ingress rule for the domain that handles all routes
 			ingress = append(ingress, cloudflare.UnvalidatedIngressRule{
 				Hostname: domain,
 				Service:  os.Getenv("TRAEFIK_SERVICE_ENDPOINT"),
 				OriginRequest: &cloudflare.OriginRequestConfig{
 					HTTPHostHeader: &domain,
-					NoTLSVerify:    boolPtr(true), // Skip TLS verification for internal traffic
+					NoTLSVerify:    boolPtr(true), // Skip TLS for internal traffic
 				},
 			})
 		}
 
-		// add catch-all rule
+		// Add catch-all rule
 		ingress = append(ingress, cloudflare.UnvalidatedIngressRule{
 			Service: "http_status:404",
 		})
 
-		err = updateTunnels(ctx, cf, ingress)
-		if err != nil {
-			log.Fatal(err)
+		// Update tunnel configuration
+		if err := updateTunnels(ctx, cf, ingress); err != nil {
+			log.Errorf("Failed to update tunnels: %v", err)
+			continue
 		}
 	}
 }
@@ -146,18 +142,16 @@ func boolPtr(b bool) *bool {
 	return &b
 }
 
-func pollTraefikRouters(client *resty.Client) (ch chan PollResponse) {
-	ch = make(chan PollResponse)
+// Poll Traefik routers periodically
+func pollTraefikRouters(client *resty.Client) chan PollResponse {
+	ch := make(chan PollResponse)
 	go func() {
-		defer func() {
-			close(ch)
-		}()
+		defer close(ch)
 		r := rand.New(rand.NewSource(time.Now().UnixNano()))
-		c := time.Tick(10 * time.Second)
+		ticker := time.Tick(10 * time.Second)
 
-		for range c {
+		for range ticker {
 			var pollRes PollResponse
-
 			resp, err := client.R().
 				EnableTrace().
 				SetResult(&pollRes.Routers).
@@ -167,70 +161,69 @@ func pollTraefikRouters(client *resty.Client) (ch chan PollResponse) {
 			if err != nil {
 				log.Errorf("Error polling Traefik API: %v", err)
 				ch <- pollRes
-				time.Sleep(5 * time.Second) // Wait before retrying
+				time.Sleep(5 * time.Second)
 				continue
 			}
 
 			if resp.StatusCode() != 200 {
 				log.Errorf("Unexpected status code from Traefik API: %d", resp.StatusCode())
 				pollRes.Err = fmt.Errorf("unexpected status code: %d", resp.StatusCode())
 				ch <- pollRes
-				time.Sleep(5 * time.Second) // Wait before retrying
+				time.Sleep(5 * time.Second)
 				continue
 			}
 
 			ch <- pollRes
-
 			jitter := time.Duration(r.Int31n(5000)) * time.Millisecond
 			time.Sleep(jitter)
 		}
 	}()
-	return
+	return ch
 }
 
+// Update Cloudflare tunnel configuration and DNS records
 func updateTunnels(ctx context.Context, cf *cloudflare.API, ingress []cloudflare.UnvalidatedIngressRule) error {
-	// Get Current tunnel config
 	aid := cloudflare.AccountIdentifier(os.Getenv("CLOUDFLARE_ACCOUNT_ID"))
+
+	// Fetch current tunnel config
 	cfg, err := cf.GetTunnelConfiguration(ctx, aid, os.Getenv("CLOUDFLARE_TUNNEL_ID"))
 	if err != nil {
-		return fmt.Errorf("unable to pull current tunnel config, %s", err.Error())
+		return fmt.Errorf("failed to fetch tunnel config: %v", err)
 	}
 
-	// Update config with new ingress rules
+	// Update with new ingress rules
 	cfg.Config.Ingress = ingress
-	cfg, err = cf.UpdateTunnelConfiguration(ctx, aid, cloudflare.TunnelConfigurationParams{
+	_, err = cf.UpdateTunnelConfiguration(ctx, aid, cloudflare.TunnelConfigurationParams{
 		TunnelID: os.Getenv("CLOUDFLARE_TUNNEL_ID"),
 		Config:   cfg.Config,
 	})
 	if err != nil {
-		return fmt.Errorf("unable to update tunnel config, %s", err.Error())
+		return fmt.Errorf("failed to update tunnel config: %v", err)
 	}
+	log.Info("Tunnel configuration updated successfully")
 
-	log.Info("tunnel config updated")
-
-	// Update DNS to point to new tunnel
-	for _, i := range ingress {
-		if i.Hostname == "" {
+	// Update DNS records
+	for _, rule := range ingress {
+		if rule.Hostname == "" {
 			continue
 		}
 
-		var proxied bool = true
-
+		proxied := true
 		record := cloudflare.DNSRecord{
 			Type:    "CNAME",
-			Name:    i.Hostname,
+			Name:    rule.Hostname,
 			Content: fmt.Sprintf("%s.cfargotunnel.com", os.Getenv("CLOUDFLARE_TUNNEL_ID")),
 			TTL:     1,
 			Proxied: &proxied,
 		}
 
 		zid := cloudflare.ZoneIdentifier(os.Getenv("CLOUDFLARE_ZONE_ID"))
-		r, _, err := cf.ListDNSRecords(ctx, zid, cloudflare.ListDNSRecordsParams{Name: i.Hostname})
+		records, _, err := cf.ListDNSRecords(ctx, zid, cloudflare.ListDNSRecordsParams{Name: rule.Hostname})
 		if err != nil {
-			return fmt.Errorf("err checking DNS records, %s", err.Error())
+			return fmt.Errorf("failed to list DNS records for %s: %v", rule.Hostname, err)
 		}
 
-		if len(r) == 0 {
+		if len(records) == 0 {
 			_, err := cf.CreateDNSRecord(ctx, zid, cloudflare.CreateDNSRecordParams{
 				Name:    record.Name,
 				Type:    record.Type,
@@ -239,35 +232,31 @@ func updateTunnels(ctx context.Context, cf *cloudflare.API, ingress []cloudflare
 				Proxied: record.Proxied,
 			})
 			if err != nil {
-				return fmt.Errorf("unable to create DNS record, %s", err.Error())
+				return fmt.Errorf("failed to create DNS record for %s: %v", rule.Hostname, err)
 			}
-			log.WithFields(log.Fields{
-				"domain": record.Name,
-			}).Info("DNS created")
+			log.WithFields(log.Fields{"domain": record.Name}).Info("DNS record created")
 			continue
 		}
 
-		if r[0].Content != record.Content {
+		if records[0].Content != record.Content {
 			_, err = cf.UpdateDNSRecord(ctx, zid, cloudflare.UpdateDNSRecordParams{
-				ID:      r[0].ID, // Use the actual ID from the retrieved record
+				ID:      records[0].ID,
 				Name:    record.Name,
 				Type:    record.Type,
 				Content: record.Content,
 				TTL:     record.TTL,
 				Proxied: record.Proxied,
 			})
 			if err != nil {
-				return fmt.Errorf("could not update record for %s, %s", i.Hostname, err)
+				return fmt.Errorf("failed to update DNS record for %s: %v", rule.Hostname, err)
 			}
-			log.WithFields(log.Fields{
-				"domain": record.Name,
-			}).Info("DNS updated")
+			log.WithFields(log.Fields{"domain": record.Name}).Info("DNS record updated")
 		}
 	}
-
 	return nil
 }
 
+// Check if a slice contains a string
 func contains(s []string, e string) bool {
 	for _, a := range s {
 		if a == e {