refactor: improve handling of deployable fragments in ApplyRevision and buildPreviewFragments functions. Introduce isDeployableBirdFragment to filter out UI-only preview keys, and update related logic in the API to ensure proper job queuing and response handling for module refresh operations.

internal/pipeline/refresh.go

@@ -3,6 +3,7 @@ package pipeline
 import (
 	"context"
 	"crypto/sha256"
+	"encoding/json"
 	"fmt"
 	"io"
 	"net/http"
@@ -17,6 +18,12 @@ import (
 	"github.com/google/uuid"
 )
 
+const (
+	birdFilterNameV4    = "evobgp_export_v4"
+	birdFilterNameV6    = "evobgp_export_v6"
+	auxBirdFullExpanded = "_bird_full_expanded.conf"
+)
+
 // MaterializedASPrefixKey returns the revision snapshot key for an AS-only entry (not a CIDR).
 func MaterializedASPrefixKey(asn int64) string {
 	return fmt.Sprintf("as:%d", asn)
@@ -127,7 +134,7 @@ func RefreshModule(ctx context.Context, st store.Backend, hc *http.Client, tenan
 	revisionID = uuid.NewString()
 	parent := parentRevision(st, tenantID, moduleID)
 	hash := hashMaterialization(moduleID, rows)
-	preview, err := buildPreviewFragments(revisionID, rows)
+	preview, err := buildPreviewFragments(st, tenantID, moduleID, revisionID, rows)
 	if err != nil {
 		return "", err
 	}
@@ -179,7 +186,7 @@ func hashMaterialization(moduleID string, rows []store.PrefixRow) string {
 	return fmt.Sprintf("sha256:%x", h.Sum(nil))
 }
 
-func buildPreviewFragments(revisionID string, rows []store.PrefixRow) (map[string]string, error) {
+func buildPreviewFragments(st store.Backend, tenantID, moduleID, revisionID string, rows []store.PrefixRow) (map[string]string, error) {
 	var v4, v6 []netip.Prefix
 	var pathASNs []int64
 	for _, pr := range rows {
@@ -202,29 +209,237 @@ func buildPreviewFragments(revisionID string, rows []store.PrefixRow) (map[strin
 			v6 = append(v6, pfx.Masked())
 		}
 	}
-	f4, err := birdfmt.RenderExportFilterIPv4("evobgp_export_v4", v4, pathASNs)
+	f4, err := birdfmt.RenderExportFilterIPv4(birdFilterNameV4, v4, pathASNs)
 	if err != nil {
 		return nil, err
 	}
-	f6, err := birdfmt.RenderExportFilterIPv6("evobgp_export_v6", v6, pathASNs)
+	f6, err := birdfmt.RenderExportFilterIPv6(birdFilterNameV6, v6, pathASNs)
 	if err != nil {
 		return nil, err
 	}
-	birdD := birdfmt.JoinFragments(birdfmt.ManagedBanner(revisionID), f4, f6)
-	main := `# EvoBGP generated (pipeline refresh)
-router id 192.0.2.1;
-include "bird.d/evobgp_generated.conf";
+	staticV4 := birdfmt.RenderStaticIPv4Protocol("evobgp_prefixes_v4", v4)
+	staticV6 := birdfmt.RenderStaticIPv6Protocol("evobgp_prefixes_v6", v6)
 
-protocol device {
+	locals := birdLocalsFromStore(st, tenantID)
+	peersBody, err := renderPeersBirdFragment(st, tenantID, locals)
+	if err != nil {
+		return nil, err
+	}
+
+	main, err := birdfmt.RenderMainBirdConf(birdfmt.MainBirdConfOptions{
+		RouterID: locals.routerID,
+		Includes: birdfmt.StandardIncludeFragments(),
+		Preamble: fmt.Sprintf("EvoBGP module %s revision %s", moduleID, revisionID),
+	})
+	if err != nil {
+		return nil, err
+	}
+
+	p4 := birdfmt.FragmentIncludePath(birdfmt.FragmentFiltersV4)
+	p6 := birdfmt.FragmentIncludePath(birdfmt.FragmentFiltersV6)
+	px4 := birdfmt.FragmentIncludePath(birdfmt.FragmentPrefixesV4)
+	px6 := birdfmt.FragmentIncludePath(birdfmt.FragmentPrefixesV6)
+	pPeers := birdfmt.FragmentIncludePath(birdfmt.FragmentPeers)
+
+	out := map[string]string{
+		"bird.conf": main,
+		p4:          birdfmt.JoinFragments(birdfmt.ManagedBanner(revisionID), f4),
+		p6:          birdfmt.JoinFragments(birdfmt.ManagedBanner(revisionID), f6),
+		px4:         birdfmt.JoinFragments(birdfmt.ManagedBanner(revisionID), staticV4),
+		px6:         birdfmt.JoinFragments(birdfmt.ManagedBanner(revisionID), staticV6),
+		pPeers:      peersBody,
+	}
+	out[auxBirdFullExpanded] = buildExpandedBirdText(main, out)
+	return out, nil
 }
 
-protocol direct {
-    ipv4;
-    ipv6;
+type birdLocals struct {
+	routerID string
+	localV4  string
+	localV6  string
+	localASN uint32
 }
-`
-	return map[string]string{
-		"bird.conf":                    main,
-		"bird.d/evobgp_generated.conf": birdD,
-	}, nil
+
+func birdLocalsFromStore(st store.Backend, tenantID string) birdLocals {
+	def := birdLocals{
+		routerID: "192.0.2.1",
+		localV4:  "192.0.2.1",
+		localV6:  "2001:db8::1",
+		localASN: 65001,
+	}
+	settings, err := st.ListGlobalSettings(tenantID)
+	if err != nil {
+		return def
+	}
+	loc := def
+	if s := stringFromSettingsMap(settings, "bird_router_id"); s != "" {
+		loc.routerID = s
+	}
+	if s := stringFromSettingsMap(settings, "bird_local_ipv4"); s != "" {
+		loc.localV4 = s
+	}
+	if s := stringFromSettingsMap(settings, "bird_local_ipv6"); s != "" {
+		loc.localV6 = s
+	}
+	if n := uint32FromSettingsMap(settings, "bird_local_asn"); n != 0 {
+		loc.localASN = n
+	}
+	return loc
+}
+
+func stringFromSettingsMap(m map[string]any, key string) string {
+	v, ok := m[key]
+	if !ok || v == nil {
+		return ""
+	}
+	s, ok := v.(string)
+	if !ok {
+		return ""
+	}
+	return strings.TrimSpace(s)
+}
+
+func uint32FromSettingsMap(m map[string]any, key string) uint32 {
+	v, ok := m[key]
+	if !ok || v == nil {
+		return 0
+	}
+	switch x := v.(type) {
+	case float64:
+		if x >= 1 && x <= 4294967295 {
+			return uint32(x)
+		}
+	case int:
+		if x >= 1 && x <= 4294967295 {
+			return uint32(x)
+		}
+	case int64:
+		if x >= 1 && x <= 4294967295 {
+			return uint32(x)
+		}
+	case string:
+		if n, err := strconv.ParseUint(strings.TrimSpace(x), 10, 32); err == nil && n >= 1 {
+			return uint32(n)
+		}
+	}
+	return 0
+}
+
+type peerPolicyJSON struct {
+	LocalIPv4 string  `json:"local_ipv4"`
+	LocalIPv6 string  `json:"local_ipv6"`
+	LocalASN  float64 `json:"local_asn"`
+}
+
+func renderPeersBirdFragment(st store.Backend, tenantID string, loc birdLocals) (string, error) {
+	peers := st.ListPeers(tenantID)
+	var parts []string
+	parts = append(parts, birdfmt.ManagedBanner("peers"))
+	for _, p := range peers {
+		if p == nil || !p.Enabled {
+			continue
+		}
+		neighbor := strings.TrimSpace(p.Neighbor)
+		if neighbor == "" {
+			continue
+		}
+		addr, err := netip.ParseAddr(neighbor)
+		if err != nil {
+			continue
+		}
+		if !store.ValidASN(p.RemoteASN) {
+			continue
+		}
+		pol := parsePeerPolicies(p.PoliciesJSON)
+		lv4 := loc.localV4
+		if strings.TrimSpace(pol.LocalIPv4) != "" {
+			lv4 = strings.TrimSpace(pol.LocalIPv4)
+		}
+		lv6 := loc.localV6
+		if strings.TrimSpace(pol.LocalIPv6) != "" {
+			lv6 = strings.TrimSpace(pol.LocalIPv6)
+		}
+		asn := loc.localASN
+		if pol.LocalASN >= 1 && pol.LocalASN <= 4294967295 {
+			asn = uint32(pol.LocalASN)
+		}
+		proto := peerProtocolName(p.ID)
+		ra := uint32(p.RemoteASN)
+		if addr.Is4() {
+			s, err := birdfmt.RenderProtocolBGPIPv4(birdfmt.BGPPeerIPv4Options{
+				ProtocolName: proto,
+				LocalIP:      lv4,
+				LocalASN:     asn,
+				NeighborIP:   addr.String(),
+				NeighborASN:  ra,
+				ExportFilter: birdFilterNameV4,
+			})
+			if err != nil {
+				return "", err
+			}
+			parts = append(parts, s)
+			continue
+		}
+		if addr.Is6() {
+			s, err := birdfmt.RenderProtocolBGPIPv6(birdfmt.BGPPeerIPv6Options{
+				ProtocolName: proto,
+				LocalIP:      lv6,
+				LocalASN:     asn,
+				NeighborIP:   addr.String(),
+				NeighborASN:  ra,
+				ExportFilter: birdFilterNameV6,
+			})
+			if err != nil {
+				return "", err
+			}
+			parts = append(parts, s)
+		}
+	}
+	if len(parts) == 1 {
+		parts = append(parts, "# (no enabled BGP peers with valid neighbor addresses)\n")
+	}
+	return birdfmt.JoinFragments(parts...), nil
+}
+
+func parsePeerPolicies(raw string) peerPolicyJSON {
+	raw = strings.TrimSpace(raw)
+	if raw == "" || raw == "{}" {
+		return peerPolicyJSON{}
+	}
+	var pol peerPolicyJSON
+	_ = json.Unmarshal([]byte(raw), &pol)
+	return pol
+}
+
+func peerProtocolName(peerID string) string {
+	s := strings.ReplaceAll(strings.TrimSpace(peerID), "-", "")
+	if len(s) > 16 {
+		s = s[:16]
+	}
+	if s == "" {
+		s = "x"
+	}
+	return "evobgp_p_" + s
+}
+
+// buildExpandedBirdText concatenates bird.conf and the contents of each standard include (for UI / preview).
+func buildExpandedBirdText(main string, frags map[string]string) string {
+	var b strings.Builder
+	b.WriteString(strings.TrimSpace(main))
+	b.WriteString("\n")
+	for _, inc := range birdfmt.StandardIncludeFragments() {
+		b.WriteString("\n# ---------- include \"")
+		b.WriteString(inc)
+		b.WriteString("\" ----------\n")
+		body := strings.TrimSpace(frags[inc])
+		if body == "" {
+			b.WriteString("# (empty)\n")
+			continue
+		}
+		b.WriteString(body)
+		if !strings.HasSuffix(body, "\n") {
+			b.WriteByte('\n')
+		}
+	}
+	return b.String()
 }