pmcf 6.20.0 → 6.20.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pmcf",
-  "version": "6.20.0",
+  "version": "6.20.2",
   "publishConfig": {
     "access": "public"
   },
@@ -50,10 +50,10 @@
     "lint:docs": "documentation lint ./src**/*.mjs"
   },
   "dependencies": {
-    "aggregated-map": "^1.0.8",
+    "aggregated-map": "^1.0.10",
     "content-entry-transform": "^1.7.0",
-    "ip-utilties": "^3.10.0",
-    "npm-pkgbuild": "^20.8.9",
+    "ip-utilties": "^3.10.1",
+    "npm-pkgbuild": "^20.8.11",
     "pacc": "^11.0.2",
     "package-directory": "^8.2.0",
     "yaml": "^2.9.0"
@@ -63,7 +63,7 @@
     "ava": "^8.0.1",
     "c8": "^12.0.0",
     "documentation": "^14.0.3",
-    "semantic-release": "^25.0.8"
+    "semantic-release": "^25.0.9"
   },
   "engines": {
     "node": ">=26.5.1"

package/src/services/bind.mjs

@@ -1,4 +1,4 @@
-import { join, dirname } from "node:path";
+import { join } from "node:path";
 import { createHmac } from "node:crypto";
 import { FileContentProvider } from "npm-pkgbuild";
 import { reverseArpa, FAMILY_IPV4, FAMILY_IPV6 } from "ip-utilties";
@@ -196,6 +196,10 @@ class bind_group extends Base {
       ...string_set_attribute,
       name: "domains"
     },
+    foreignDomains: {
+      ...string_set_attribute,
+      name: "foreignDomains"
+    },
     zones: {
       ...default_collection_attribute,
       type: bind_zone,
@@ -258,6 +262,7 @@ class bind_group extends Base {
     addType(this);
   }
 
+  foreignDomains = new Set();
   access = [];
   allowedUpdates = [];
   notify = true;
@@ -335,13 +340,13 @@ class bind_group extends Base {
   intoCatalog(zone, locationName) {
     if (this.hasCatalog) {
       const catalogConfig = this.zoneConfigs.getOrInsertComputed(
-        `catalog.${zone.id}`,
-        domain => new bind_zone_config(this, `${domain}.zone.conf`)
+        `catalog.${locationName}`,
+        id => new bind_zone_config(this, `${id}.zone.conf`)
       );
 
       const catalogZone = this._zones.getOrInsertComputed(
-        `catalog.${zone.id}`,
-        domain => new catalog_zone(this, domain, catalogConfig, locationName)
+        `catalog.${locationName}`,
+        id => new catalog_zone(this, id, catalogConfig, locationName)
       );
 
       const hash = createHmac("sha1", zone.id).digest("hex");
@@ -356,6 +361,7 @@ class bind_group extends Base {
   get zones() {
     const entries = [...this.entries];
 
+
     if (!this._zones && entries.length > 0) {
       this._zoneConfigs = new Map();
       this._zones = new Map();
@@ -398,10 +404,54 @@ class bind_group extends Base {
 
             if (host && !hosts.has(host)) {
               hosts.add(host);
-              for (const foreignDomainName of host.foreignDomainNames) {
-                zone.records.add(
-                  DNSRecord("outfacing", "PTR", dnsFullName(foreignDomainName))
+
+              for (let foreignDomain of host.foreignDomainNames) {
+                const wildcard = foreignDomain.startsWith("*.");
+                if (wildcard) {
+                  foreignDomain = foreignDomain.substring(2);
+                }
+
+                this.foreignDomains.add(foreignDomain);
+
+                const config = this.zoneConfigs.getOrInsertComputed(
+                  foreignDomain,
+                  domain => new bind_zone_config(this, `${domain}.zone.conf`)
                 );
+
+                const zone = this._zones.getOrInsertComputed(
+                  foreignDomain,
+                  domain =>
+                    this.intoCatalog(
+                      new bind_zone(this, domain, config, locationName),
+                      locationName
+                    )
+                );
+
+                for (const na of host.networkAddresses(
+                  na => na.networkInterface.kind !== "loopback"
+                )) {
+                  zone.records.add(
+                    DNSRecord(
+                      "@",
+                      dnsRecordTypeForAddressFamily(na.family),
+                      na.address
+                    )
+                  );
+
+                  if (wildcard) {
+                    zone.records.add(
+                      DNSRecord(
+                        "*",
+                        dnsRecordTypeForAddressFamily(na.family),
+                        na.address
+                      )
+                    );
+                  }
+                }
+
+                /*zone.records.add(
+                  DNSRecord("outfacing", "PTR", dnsFullName(foreignDomain))
+                );*/
               }
 
               const sm = new Map();
@@ -487,6 +537,14 @@ class bind_group extends Base {
       await config.write(outputControl, this);
     }
 
+    if (this.foreignDomains.size) {
+      addHook(
+        outputControl.packageData,
+        "post_upgrade",
+        `/usr/bin/named-hostname-update ${[...this.foreignDomains].join(" ")}`
+      );
+    }
+
     return outputControl.packageData;
   }
 }
@@ -616,82 +674,11 @@ export class bind extends ExtraSourceService {
     const present = await this.writeForwarders(outputControl);
 
     if (hasContent || present) {
-      //console.log(packageData);
       yield packageData;
     }
   }
-
-  async *generateOutfacingDefs(outputControl, sources) {
-    for (const source of sources) {
-      for (const host of source.hosts.values()) {
-        this.outfacingZones(
-          outputControl,
-          host,
-          this.groups.get("internal"),
-          this.defaultRecords
-        );
-      }
-    }
-
-    if (outputControl.configs.length) {
-      addHook(
-        outputControl.packageData,
-        "post_upgrade",
-        `/usr/bin/named-hostname-update ${outputControl.configs
-          .map(config => config.zones.map(zone => zone.id))
-          .flat()
-          .join(" ")}`
-      );
-
-      await this.writeZones(outputControl);
-
-      yield outputControl.packageData;
-    }
-  }
-
-  outfacingZones(outputControl, host, group, records) {
-    host.foreignDomainNames.map(domain => {
-      const wildcard = domain.startsWith("*.");
-      if (wildcard) {
-        domain = domain.substring(2);
-      }
-
-      const zone = {
-        id: domain,
-        file: `${host.owner.name}/outfacing/${domain}.zone`,
-        records: new Set(records)
-      };
-      const config = {
-        group,
-        name: `${domain}.zone.conf`,
-        type: this.serverType,
-        zones: [zone]
-      };
-      zone.config = config;
-      outputControl.configs.push(config);
-
-      if (this.hasLocationRecord) {
-        zone.records.add(DNSRecord("location", "TXT", host.owner.name));
-      }
-      for (const na of host.networkAddresses(
-        na => na.networkInterface.kind !== "loopback"
-      )) {
-        zone.records.add(
-          DNSRecord("@", dnsRecordTypeForAddressFamily(na.family), na.address)
-        );
-
-        if (wildcard) {
-          zone.records.add(
-            DNSRecord("*", dnsRecordTypeForAddressFamily(na.family), na.address)
-          );
-        }
-      }
-
-      //this.assignCatalog(outputControl, zone, `outfacting.${host.owner.name}`);
-    });
-  }
 }
 
 function newOutputControl(packageData, dir, permissions) {
-  return { configs: [], catalogs: new Map(), packageData, dir, permissions };
+  return { packageData, dir, permissions };
 }