@takodotid/circuit 0.43.1 → 1.0.0-rc.2

package/src/platforms/junos/bgp.ts

@@ -2,12 +2,9 @@
 
 import { Address } from "../../core/address";
 import { Secrets } from "../../core/secrets";
-import type { Device, Family, Neighbor, NeighborSettings, PolicyRule } from "../../schema";
+import type { Device, Family, Neighbor, NeighborSettings, PolicyRule, Prefix, PrefixSet, RouteRule } from "../../model";
 import { JunosRender, type JunosStatements } from "./render";
 
-type AnyRule = PolicyRule<string, string>;
-type AnyNeighbor = Neighbor<string, string, string>;
-
 /** BGP sessions, the policies they use, prefix sets and RPKI servers, added to one device's statements. */
 export class JunosBgp {
     /** The policy a session uses when it states none, so that it learns or announces nothing. */
@@ -41,11 +38,23 @@ export class JunosBgp {
     }
 
     /** A neighbor's settings with its group's beneath them. */
-    static settingsOf(device: Device, neighbor: AnyNeighbor): NeighborSettings<string, string> {
-        const group = neighbor.group ? device.routing?.bgp?.groups?.[neighbor.group] : undefined;
+    static settingsOf(device: Device, neighbor: Neighbor): NeighborSettings {
+        const group = neighbor.neighbor_group ? device.routing?.bgp?.neighbor_groups?.[neighbor.neighbor_group] : undefined;
         return { ...group, ...neighbor };
     }
 
+    /** A prefix set's prefixes, written as a list or as a map of named prefixes. A set fetched by `refresh` has none here. */
+    static prefixesOf(set: PrefixSet): Prefix[] {
+        if (!("prefixes" in set)) return [];
+
+        return Array.isArray(set.prefixes) ? [...(set.prefixes as readonly Prefix[])] : Object.values(set.prefixes);
+    }
+
+    /** A rule on routes: neither a call nor a communities rule. */
+    static isRouteRule(rule: PolicyRule): rule is RouteRule {
+        return !("call" in rule && rule.call !== undefined) && !("communities" in rule && rule.communities !== undefined);
+    }
+
     /** A name made of a value's words, for a community or a path-length list: `64500:*` becomes `64500-any`. */
     private static slug(value: string): string {
         return value.replace(/\*/g, "any").replace(/[^A-Za-z0-9]+/g, "-");
@@ -57,13 +66,14 @@ export class JunosBgp {
     }
 
     /** A term's name: its place, then the rule's description so a reader sees it on the device. */
-    private static termName(label: string, rule: AnyRule): string {
+    private static termName(label: string, rule: RouteRule): string {
         return JunosRender.quote(rule.description ? `${label} ${rule.description}` : label);
     }
 
     private sessions(): void {
         const bgp = this.device.routing?.bgp;
-        if (!bgp) return;
+        // Without our AS there is no BGP to write; `unsupported()` names it.
+        if (!bgp || bgp.asn === undefined) return;
 
         this.out.set("routing-options autonomous-system", bgp.asn);
 
@@ -71,35 +81,37 @@ export class JunosBgp {
         let rejectAll = false;
         let exports = false;
 
-        // One group per session: a group holds one type, internal or external, and the config's groups are only shared settings.
+        // One group per session: a group holds one type, internal or external, and the config's neighbor groups are only shared settings.
         for (const [name, neighbor] of Object.entries(bgp.neighbors ?? {})) {
+            if (!neighbor) continue;
+
             const settings = JunosBgp.settingsOf(this.device, neighbor);
             const group = `protocols bgp group ${name}`;
 
             this.out.set(group, "type", settings.remote_as === bgp.asn ? "internal" : "external");
             this.out.set(group, "peer-as", settings.remote_as!);
             if (settings.description) this.out.set(group, "description", JunosRender.quote(settings.description));
-            if (settings.local_address) this.out.set(group, "local-address", settings.local_address);
+            if (settings.local_address) this.out.set(group, "local-address", Address.host(settings.local_address));
             if (settings.multihop) this.out.set(group, "multihop");
             if (settings.passive) this.out.set(group, "passive");
             if (settings.hold_time !== undefined) this.out.set(group, "hold-time", settings.hold_time);
             if (settings.password) this.out.set(group, "authentication-key", Secrets.marker(settings.password));
             if (settings.bfd) JunosRender.bfd(this.out, group, this.device);
 
-            this.out.set(group, "import", settings.import ?? JunosBgp.REJECT_ALL);
+            this.out.set(group, "import", settings.import_policy ?? JunosBgp.REJECT_ALL);
 
-            if (settings.export) {
+            if (settings.export_policy) {
                 exports = true;
                 this.out.set(group, "export", JunosBgp.ORIGIN);
-                this.out.set(group, "export", settings.export);
+                this.out.set(group, "export", settings.export_policy);
             } else this.out.set(group, "export", JunosBgp.REJECT_ALL);
 
-            for (const policy of [settings.import, settings.export]) {
+            for (const policy of [settings.import_policy, settings.export_policy]) {
                 if (policy) used.add(policy);
                 else rejectAll = true;
             }
 
-            for (const family of settings.families ?? [Address.family(neighbor.address)]) {
+            for (const family of settings.address_families ?? [Address.family(neighbor.address)]) {
                 const nlri = `${group} family ${JunosBgp.FAMILY[family]} unicast`;
                 this.out.set(nlri);
 
@@ -126,18 +138,22 @@ export class JunosBgp {
         this.out.set(statement, "term bgp from protocol bgp");
         this.out.set(statement, "term bgp then next policy");
 
-        const networks = this.device.routing?.bgp?.networks ?? [];
-        for (const prefix of networks) this.out.set(statement, "term networks from route-filter", prefix, "exact");
-        if (networks.length) this.out.set(statement, "term networks then next policy");
+        // The term keeps its 0.x name, `networks`, so a device that holds it is not rewritten.
+        const originated = this.device.routing?.bgp?.originated_prefixes ?? [];
+        for (const prefix of originated) this.out.set(statement, "term networks from route-filter", prefix, "exact");
+        if (originated.length) this.out.set(statement, "term networks then next policy");
 
         this.out.set(statement, "term others then reject");
     }
 
     private prefixSets(): void {
-        for (const [name, set] of Object.entries(this.device.prefix_sets ?? {})) {
+        for (const [name, set] of Object.entries(this.device.routing?.prefix_sets ?? {})) {
+            if (!set) continue;
+
             const list = `policy-options prefix-list ${name}`;
+            const prefixes = JunosBgp.prefixesOf(set);
 
-            if ("prefixes" in set && set.prefixes.length) for (const prefix of set.prefixes) this.out.set(list, prefix);
+            if (prefixes.length) for (const prefix of prefixes) this.out.set(list, prefix);
             else this.out.set(list);
 
             if ("source" in set) this.out.note(`${JunosBgp.GENERATED}${list}`);
@@ -151,31 +167,33 @@ export class JunosBgp {
     }
 
     /** The family a rule is limited to, by its match: a family, a prefix, or a prefix set of one family. */
-    private familyOfRule(rule: AnyRule): Family | undefined {
-        const match = rule.match;
+    private familyOfRule(rule: RouteRule): Family | undefined {
+        const match = rule.if;
         if (match?.family) return match.family;
 
         if (match?.prefix) return Address.family(Address.host(match.prefix));
 
-        const set = match?.prefix_set ? this.device.prefix_sets?.[match.prefix_set] : undefined;
+        const set = match?.prefix_set ? this.device.routing?.prefix_sets?.[match.prefix_set] : undefined;
         if (set && "source" in set) return set.source.family;
 
-        if (set?.prefixes[0]) return Address.family(Address.host(set.prefixes[0]));
+        const first = set && JunosBgp.prefixesOf(set)[0];
+        if (first) return Address.family(Address.host(first));
 
         return undefined;
     }
 
     /** A policy's rules with each call replaced by the rules it calls, in order. A called policy that decides nothing hands back to the caller, as it does on every platform. */
-    private flatten(policy: string, label: string, seen: string[]): { label: string; rule: AnyRule }[] {
-        const rules = this.device.policies?.[policy] ?? [];
-        const flat: { label: string; rule: AnyRule }[] = [];
+    private flatten(policy: string, label: string, seen: string[]): { label: string; rule: RouteRule }[] {
+        const rules = this.device.routing?.policies?.[policy] ?? [];
+        const flat: { label: string; rule: RouteRule }[] = [];
 
         rules.forEach((rule, index) => {
             const here = label ? `${label}.${index + 1}` : `${index + 1}`;
 
-            if (rule.call && !seen.includes(rule.call)) flat.push(...this.flatten(rule.call, here, [...seen, rule.call]));
+            if ("call" in rule && rule.call && !seen.includes(rule.call)) flat.push(...this.flatten(rule.call, here, [...seen, rule.call]));
 
-            if (rule.match || rule.set || rule.action) flat.push({ label: here, rule });
+            // A communities rule is not written here; `unsupported()` names it.
+            if (JunosBgp.isRouteRule(rule) && (rule.if || rule.set || rule.then)) flat.push({ label: here, rule });
         });
 
         return flat;
@@ -189,7 +207,7 @@ export class JunosBgp {
         for (const { label, rule } of flat) {
             const family = this.familyOfRule(rule);
             // A next hop only means something to routes of its own family, and one term cannot filter prefixes of both, so a rule for both families splits into a term for each.
-            const split = !family && (rule.set?.next_hop || rule.match?.prefix_length) ? (["ipv4", "ipv6"] as const) : [family];
+            const split = !family && (rule.set?.next_hop || rule.if?.prefix_length) ? (["ipv4", "ipv6"] as const) : [family];
 
             for (const part of split) {
                 const name =
@@ -201,12 +219,12 @@ export class JunosBgp {
         }
 
         const last = flat.at(-1)?.rule;
-        const decides = last !== undefined && !last.match && last.action !== undefined;
+        const decides = last !== undefined && !last.if && last.then !== undefined;
         if (!decides) this.out.set(statement, "term circuit-default then reject");
     }
 
-    private term(term: string, rule: AnyRule, family: Family | undefined, splitFamily: boolean): void {
-        const match = rule.match ?? {};
+    private term(term: string, rule: RouteRule, family: Family | undefined, splitFamily: boolean): void {
+        const match = rule.if ?? {};
         const set = rule.set ?? {};
         const from: (string | number)[][] = [];
         const then: (string | number)[][] = [];
@@ -232,9 +250,9 @@ export class JunosBgp {
             from.push(["as-path", name]);
         }
 
-        if (match.through_as !== undefined) {
-            const name = `circuit-through-${match.through_as}`;
-            this.out.set(`policy-options as-path ${name}`, JunosRender.quote(`.* ${match.through_as} .*`));
+        if (match.as_path_contains !== undefined) {
+            const name = `circuit-through-${match.as_path_contains}`;
+            this.out.set(`policy-options as-path ${name}`, JunosRender.quote(`.* ${match.as_path_contains} .*`));
             from.push(["as-path", name]);
         }
 
@@ -242,7 +260,7 @@ export class JunosBgp {
 
         // Members of one named community must all be present, so a rule matching both kinds names them together.
         const wanted = [
-            ...(match.community ? [JunosBgp.member(match.community, false)] : []),
+            ...(match.standard_community ? [JunosBgp.member(match.standard_community, false)] : []),
             ...(match.large_community ? [JunosBgp.member(match.large_community, true)] : []),
         ];
 
@@ -252,22 +270,25 @@ export class JunosBgp {
         if (set.med !== undefined) then.push(["metric", set.med]);
 
         if (set.prepend !== undefined) {
-            const asn = this.device.routing!.bgp!.asn;
+            const asn = this.device.routing!.bgp!.asn!;
             then.push(["as-path-prepend", JunosRender.quote(Array(set.prepend).fill(asn).join(" "))]);
         }
 
         // Replacing communities of one kind is removing every one of that kind, then adding the new ones.
         const removed = [
-            ...(set.communities ? ["*:*"] : (set.remove_communities ?? [])).map((pattern) => JunosBgp.member(pattern, false)),
+            ...(set.standard_communities ? ["*:*"] : (set.remove_standard_communities ?? [])).map((pattern) =>
+                JunosBgp.member(pattern, false)
+            ),
             ...(set.large_communities ? ["*:*:*"] : (set.remove_large_communities ?? [])).map((pattern) => JunosBgp.member(pattern, true)),
         ];
 
         const added = [
-            ...(set.communities ?? set.add_communities ?? []).map((value) => JunosBgp.member(value, false)),
+            ...(set.standard_communities ?? set.add_standard_communities ?? []).map((value) => JunosBgp.member(value, false)),
             ...(set.large_communities ?? set.add_large_communities ?? []).map((value) => JunosBgp.member(value, true)),
         ];
 
-        if (set.communities && set.add_communities) added.push(...set.add_communities.map((value) => JunosBgp.member(value, false)));
+        if (set.standard_communities && set.add_standard_communities)
+            added.push(...set.add_standard_communities.map((value) => JunosBgp.member(value, false)));
         if (set.large_communities && set.add_large_communities)
             added.push(...set.add_large_communities.map((value) => JunosBgp.member(value, true)));
 
@@ -276,7 +297,7 @@ export class JunosBgp {
 
         if (set.next_hop && (!family || Address.family(set.next_hop) === family)) then.push(["next-hop", set.next_hop]);
         if (set.blackhole) then.push(["next-hop discard"]);
-        if (rule.action) then.push([rule.action]);
+        if (rule.then) then.push([rule.then]);
 
         for (const words of from) this.out.set(term, "from", ...words);
         for (const words of then) this.out.set(term, "then", ...words);