pmcf 2.39.8 → 2.40.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pmcf",
-  "version": "2.39.8",
+  "version": "2.40.0",
   "publishConfig": {
     "access": "public"
   },

package/src/endpoint.mjs

@@ -13,10 +13,6 @@ class _Endpoint {
       delete data.type;
     }
     Object.assign(this, data);
-
-    if(this.port === undefined) {
-      throw new Error(`${this.toString()}: has no port`);
-    }
   }
 
   get type() {

package/src/network-interfaces/skeleton.mjs

@@ -28,13 +28,16 @@ export class SkeletonNetworkInterface extends ServiceOwner {
   }
 
   get host() {
-    if(this.owner instanceof Host) {
+    if (this.owner instanceof Host) {
       return this.owner;
     }
   }
 
   *hosts() {
-    yield* this.owner.hosts();
+    const host = this.host;
+    if (host) {
+      yield host;
+    }
   }
 
   get network_interface() {

package/src/service-owner.mjs

@@ -12,7 +12,6 @@ export class ServiceOwner extends Base {
   set services(service) {
     const present = this._services.find(s => s.name === service.name);
 
-   // console.log("SET SERVICE", service.name);
     if (!present) {
       this._services.push(service);
     }

package/src/service.mjs

@@ -155,7 +155,7 @@ export class Service extends Base {
   }
 
   toString() {
-    return `${this.type}`;
+    return `${super.toString()}[${this.type}]`;
   }
 
   set extends(value) {
@@ -255,24 +255,16 @@ export class Service extends Base {
       for (const ep of this.endpoints(
         e => e.protocol && e.networkInterface.kind !== "loopback"
       )) {
-        if (ep.port === undefined) {
-          console.error(
-            "Endpoint without port",
-            ep.toString(),
-            ep.networkInterface?.kind
-          );
-        } else {
-          records.push(
-            DNSRecord(
-              dnsFullName(`_${this.type}._${ep.protocol}.${domainName}`),
-              "SRV",
-              this.priority ?? 10,
-              this.weight,
-              ep.port,
-              dnsFullName(this.domainName)
-            )
-          );
-        }
+        records.push(
+          DNSRecord(
+            dnsFullName(`_${this.type}._${ep.protocol}.${domainName}`),
+            "SRV",
+            this.priority ?? 10,
+            this.weight,
+            ep.port,
+            dnsFullName(this.domainName)
+          )
+        );
       }
     }
 

package/src/services/bind.mjs

@@ -29,6 +29,12 @@ const BINDServiceTypeDefinition = {
   extends: ExtraSourceServiceTypeDefinition,
   priority: 0.1,
   properties: {
+    addresses: {
+      type: ["network", "host", "network_interface", "location", "owner"],
+      collection: true,
+      writeable: true
+    },
+
     trusted: {
       type: address_types,
       collection: true,
@@ -115,6 +121,7 @@ export class BINDService extends ExtraSourceService {
   hasLinkLocalAdresses = true;
   hasLocationRecord = true;
   notify = true;
+  _addresses = [];
   _trusted = [];
   _protected = [];
   _open = [];
@@ -161,6 +168,14 @@ export class BINDService extends ExtraSourceService {
     return [this.serial, this.refresh, this.retry, this.expire, this.minimum];
   }
 
+  set addresses(value) {
+    this._addresses.push(value);
+  }
+
+  get addresses() {
+    return this._addresses;
+  }
+
   set protected(value) {
     this._protected.push(value);
   }
@@ -202,16 +217,18 @@ export class BINDService extends ExtraSourceService {
   }
 
   async *preparePackages(dir) {
-    const location = this.owner.owner;
-    const name = location.name;
-    const p1 = join(dir, "p1") + "/";
+    const sources = this.addresses.length ? this.addresses : [this.owner];
+    const names = sources.map(a => a.fullName).join(" ");
+
+    const name = this.owner.owner.name;
+    const configPackageDir = join(dir, "config") + "/";
     const packageData = {
-      dir: p1,
-      sources: [new FileContentProvider(p1)],
+      dir: configPackageDir,
+      sources: [new FileContentProvider(configPackageDir)],
       outputs: this.outputs,
       properties: {
         name: `named-${name}`,
-        description: `named definitions for ${location.fullName}`,
+        description: `named definitions for ${names}`,
         access: "private"
       }
     };
@@ -224,7 +241,7 @@ export class BINDService extends ExtraSourceService {
 
     if (forwarders.length) {
       await writeLines(
-        join(p1, "etc/named/options"),
+        join(configPackageDir, "etc/named/options"),
         `forwarders.conf`,
         addressesStatement("forwarders", forwarders)
       );
@@ -247,18 +264,18 @@ export class BINDService extends ExtraSourceService {
     ].flat();
 
     if (acls.length) {
-      await writeLines(join(p1, "etc/named"), `0-acl-${name}.conf`, acls);
+      await writeLines(join(configPackageDir, "etc/named"), `0-acl-${name}.conf`, acls);
     }
     if (forwarders.length || acls.length) {
       yield packageData;
     }
 
-    const p2 = join(dir, "p2") + "/";
+    const zonesPackageDir = join(dir, "zones") + "/";
 
-    packageData.dir = p2;
+    packageData.dir = zonesPackageDir;
     packageData.properties = {
       name: `named-zones-${name}`,
-      description: `zone definitions for ${location.fullName}`,
+      description: `zone definitions for ${names}`,
       dependencies: ["mf-named"],
       replaces: ["mf-named-zones"],
       access: "private",
@@ -267,7 +284,7 @@ export class BINDService extends ExtraSourceService {
 
     packageData.sources = [
       new FileContentProvider(
-        p2,
+        zonesPackageDir,
         {
           mode: 0o644,
           owner: "named",
@@ -281,59 +298,46 @@ export class BINDService extends ExtraSourceService {
       )
     ];
 
-    await this.generateZoneDefs(location, packageData);
+    await this.generateZoneDefs(sources, packageData);
 
-    yield packageData;
-  }
+    const foreignZonesPackageDir = join(dir, "foreignZones") + "/";
 
-  async generateZoneDefs(location, packageData) {
-    const ttl = this.recordTTL;
-    const nameService = this.findService({ type: "dns", priority: "<10" });
-    const rname = this.administratorEmail.replace(/@/, ".");
+    packageData.dir = foreignZonesPackageDir;
+    packageData.properties = {
+      name: `named-foreign-zones-${name}`,
+      description: `foreign zone definitions for ${names}`,
+      dependencies: [`named-zones-${name}`],
+      access: "private",
+      hooks: {}
+    };
 
-    const SOARecord = DNSRecord(
-      "@",
-      "SOA",
-      dnsFullName(nameService.domainName),
-      dnsFullName(rname),
-      `(${[...this.soaUpdates].join(" ")})`
-    );
+    packageData.sources = [
+      new FileContentProvider(
+        foreignZonesPackageDir,
+        {
+          mode: 0o644,
+          owner: "named",
+          group: "named"
+        },
+        {
+          mode: 0o755,
+          owner: "named",
+          group: "named"
+        }
+      )
+    ];
 
-    const NSRecord = DNSRecord(
-      "@",
-      "NS",
-      dnsFullName(nameService.ipAddressOrDomainName)
-    );
+    await this.generateForeignDefs(sources, packageData);
 
-    console.log(`${nameService}`, nameService.ipAddressOrDomainName);
+    yield packageData;
+  }
 
+  async generateForeignDefs(sources, packageData) {
     const configs = [];
 
-    for (const host of location.hosts()) {
-      for (const domain of host.foreignDomainNames) {
-        const zone = {
-          id: domain,
-          file: `FOREIGN/${domain}.zone`,
-          records: new Set([SOARecord, NSRecord])
-        };
-
-        const config = {
-          name: `${domain}.zone.conf`,
-          zones: [zone]
-        };
-        configs.push(config);
-
-        if (this.hasLocationRecord) {
-          zone.records.add(DNSRecord("location", "TXT", host.location.name));
-        }
-
-        for (const na of host.networkAddresses(
-          na => na.networkInterface.kind != "loopback"
-        )) {
-          zone.records.add(
-            DNSRecord("@", dnsRecordTypeForAddressFamily(na.family), na.address)
-          );
-        }
+    for (const source of sources) {
+      for (const host of source.hosts()) {
+        configs.push(...this.foreignDomainZones(host, this.defaultRecords));
       }
     }
 
@@ -343,139 +347,204 @@ export class BINDService extends ExtraSourceService {
       addHook(
         packageData.properties.hooks,
         "post_upgrade",
-        `rm -f ${foreignZones.map(
-          zone => `/var/lib/named/${zone.file}.jnl`
-        )}\n` +
-          `/usr/bin/named-hostname-info ${foreignZones
-            .map(zone => zone.id)
-            .join(" ")}|/usr/bin/named-hostname-update`
+        `/usr/bin/named-hostname-info ${foreignZones
+          .map(zone => zone.id)
+          .join(" ")}|/usr/bin/named-hostname-update`
       );
     }
 
-    console.log(
-      "LOCAL DOMAINS",
-      location.localDomains,
-      location.domain,
-      location.toString()
-    );
-
-    for (const domain of location.localDomains) {
-      const locationName = location.name;
-      const reverseZones = new Map();
+    await this.writeZones(packageData, configs);
+  }
 
-      const config = {
-        name: `${domain}.zone.conf`,
-        zones: []
-      };
-      configs.push(config);
+  async generateZoneDefs(sources, packageData) {
+    const configs = [];
 
-      const locationRecord = DNSRecord("location", "TXT", locationName);
+    for (const source of sources) {
+      console.log(
+        "LOCAL DOMAINS",
+        source.localDomains,
+        source.domain,
+        source.toString()
+      );
 
-      const zone = {
-        id: domain,
-        file: `${locationName}/${domain}.zone`,
-        records: new Set([SOARecord, NSRecord, locationRecord])
-      };
-      config.zones.push(zone);
+      for (const domain of source.localDomains) {
+        const locationName = source.name;
+        const reverseZones = new Map();
 
-      if (this.hasCatalog) {
-        const catalogConfig = {
-          name: `catalog.${domain}.zone.conf`,
+        const config = {
+          name: `${domain}.zone.conf`,
           zones: []
         };
-        configs.push(catalogConfig);
-
-        zone.catalogZone = {
-          id: `catalog.${domain}`,
-          file: `${locationName}/catalog.${domain}.zone`,
-          records: new Set([
-            SOARecord,
-            NSRecord,
-            DNSRecord(dnsFullName(`version.catalog.${domain}`), "TXT", '"1"')
-          ])
+        configs.push(config);
+
+        const locationRecord = DNSRecord("location", "TXT", locationName);
+
+        const zone = {
+          id: domain,
+          file: `${locationName}/${domain}.zone`,
+          records: new Set([...this.defaultRecords, locationRecord])
         };
-        catalogConfig.zones.push(zone.catalogZone);
-      }
+        config.zones.push(zone);
+
+        if (this.hasCatalog) {
+          const catalogConfig = {
+            name: `catalog.${domain}.zone.conf`,
+            zones: []
+          };
+          configs.push(catalogConfig);
+
+          zone.catalogZone = {
+            id: `catalog.${domain}`,
+            file: `${locationName}/catalog.${domain}.zone`,
+            records: new Set([
+              ...this.defaultRecords,
+              DNSRecord(dnsFullName(`version.catalog.${domain}`), "TXT", '"1"')
+            ])
+          };
+          catalogConfig.zones.push(zone.catalogZone);
+        }
+
+        const hosts = new Set();
+        const addresses = new Set();
 
-      const hosts = new Set();
-      const addresses = new Set();
-
-      for await (const {
-        address,
-        subnet,
-        networkInterface,
-        domainNames,
-        family
-      } of location.networkAddresses()) {
-        if (
-          !this.exclude.has(networkInterface.network) &&
-          !this.excludeInterfaceKinds.has(networkInterface.kind)
-        ) {
-          const host = networkInterface.host;
+        for await (const {
+          address,
+          subnet,
+          networkInterface,
+          domainNames,
+          family
+        } of source.networkAddresses()) {
           if (
-            !addresses.has(address) &&
-            (this.hasLinkLocalAdresses || !isLinkLocal(address))
+            !this.exclude.has(networkInterface.network) &&
+            !this.excludeInterfaceKinds.has(networkInterface.kind)
           ) {
-            addresses.add(address);
-
-            for (const domainName of domainNames) {
-              zone.records.add(
-                DNSRecord(
-                  dnsFullName(domainName),
-                  dnsRecordTypeForAddressFamily(family),
-                  address
-                )
-              );
-            }
-            if (subnet && host.domain === domain) {
-              let reverseZone = reverseZones.get(subnet.address);
-
-              if (!reverseZone) {
-                const id = reverseArpa(subnet.prefix);
-                reverseZone = {
-                  id,
-                  type: "plain",
-                  file: `${locationName}/${id}.zone`,
-                  records: new Set([SOARecord, NSRecord])
-                };
-                config.zones.push(reverseZone);
-                reverseZones.set(subnet.address, reverseZone);
+            const host = networkInterface.host;
+            if (host) {
+              if (
+                !addresses.has(address) &&
+                (this.hasLinkLocalAdresses || !isLinkLocal(address))
+              ) {
+                addresses.add(address);
+
+                for (const domainName of domainNames) {
+                  zone.records.add(
+                    DNSRecord(
+                      dnsFullName(domainName),
+                      dnsRecordTypeForAddressFamily(family),
+                      address
+                    )
+                  );
+                }
+                if (subnet && host?.domain === domain) {
+                  let reverseZone = reverseZones.get(subnet.address);
+
+                  if (!reverseZone) {
+                    const id = reverseArpa(subnet.prefix);
+                    reverseZone = {
+                      id,
+                      type: "plain",
+                      file: `${locationName}/${id}.zone`,
+                      records: new Set(this.defaultRecords)
+                    };
+                    config.zones.push(reverseZone);
+                    reverseZones.set(subnet.address, reverseZone);
+                  }
+
+                  for (const domainName of host.domainNames) {
+                    reverseZone.records.add(
+                      DNSRecord(
+                        dnsFullName(reverseArpa(address)),
+                        "PTR",
+                        dnsFullName(domainName)
+                      )
+                    );
+                  }
+                }
               }
 
-              for (const domainName of host.domainNames) {
-                reverseZone.records.add(
-                  DNSRecord(
-                    dnsFullName(reverseArpa(address)),
-                    "PTR",
-                    dnsFullName(domainName)
-                  )
-                );
+              if (!hosts.has(host)) {
+                hosts.add(host);
+
+                for (const foreignDomainName of host.foreignDomainNames) {
+                  zone.records.add(
+                    DNSRecord(
+                      "outfacing",
+                      "PTR",
+                      dnsFullName(foreignDomainName)
+                    )
+                  );
+                }
+
+                //   console.log(host._services.map(s=>s.name));
+                for (const service of host._services) {
+                  for (const record of service.dnsRecordsForDomainName(
+                    host.domainName,
+                    this.hasSVRRecords
+                  )) {
+                    //console.log("SERVICE",service.toString(),record.toString())
+
+                    zone.records.add(record);
+                  }
+                }
               }
             }
           }
+        }
+      }
+    }
 
-          if (!hosts.has(host)) {
-            hosts.add(host);
+    await this.writeZones(packageData, configs);
+  }
 
-            for (const foreignDomainName of host.foreignDomainNames) {
-              zone.records.add(
-                DNSRecord("outfacing", "PTR", dnsFullName(foreignDomainName))
-              );
-            }
+  foreignDomainZones(host, records) {
+    return host.foreignDomainNames.map(domain => {
+      const zone = {
+        id: domain,
+        file: `FOREIGN/${domain}.zone`,
+        records: new Set(records)
+      };
+      const config = {
+        name: `${domain}.zone.conf`,
+        zones: [zone]
+      };
 
-            for (const service of host.findServices()) {
-              for (const record of service.dnsRecordsForDomainName(
-                host.domainName,
-                this.hasSVRRecords
-              )) {
-                zone.records.add(record);
-              }
-            }
-          }
-        }
+      if (this.hasLocationRecord) {
+        zone.records.add(DNSRecord("location", "TXT", host.location.name));
       }
-    }
+      for (const na of host.networkAddresses(
+        na => na.networkInterface.kind != "loopback"
+      )) {
+        zone.records.add(
+          DNSRecord("@", dnsRecordTypeForAddressFamily(na.family), na.address)
+        );
+      }
+
+      return config;
+    });
+  }
+
+  get defaultRecords() {
+    const nameService = this.findService({ type: "dns", priority: "<10" });
+    const rname = this.administratorEmail.replace(/@/, ".");
+
+    const SOARecord = DNSRecord(
+      "@",
+      "SOA",
+      dnsFullName(nameService.domainName),
+      dnsFullName(rname),
+      `(${[...this.soaUpdates].join(" ")})`
+    );
+
+    const NSRecord = DNSRecord(
+      "@",
+      "NS",
+      dnsFullName(nameService.ipAddressOrDomainName)
+    );
+
+    return [SOARecord, NSRecord];
+  }
 
+  async writeZones(packageData, configs) {
     for (const config of configs) {
       console.log(`config: ${config.name}`);
 
@@ -519,7 +588,7 @@ export class BINDService extends ExtraSourceService {
           zone.file,
           [...zone.records]
             .sort(sortZoneRecords)
-            .map(r => r.toString(maxKeyLength, ttl))
+            .map(r => r.toString(maxKeyLength, this.recordTTL))
         );
       }
 

package/types/network-interfaces/skeleton.d.mts

@@ -5,7 +5,7 @@ export class SkeletonNetworkInterface extends ServiceOwner {
     set extends(value: any[]);
     get extends(): any[];
     get host(): Host;
-    hosts(): Generator<any, void, any>;
+    hosts(): Generator<Host, void, unknown>;
     get network_interface(): this;
     get domainName(): any;
     get domainNames(): Set<any>;

package/types/services/bind.d.mts

@@ -254,6 +254,11 @@ export class BINDService extends ExtraSourceService {
         };
         priority: number;
         properties: {
+            addresses: {
+                type: string[];
+                collection: boolean;
+                writeable: boolean;
+            };
             trusted: {
                 type: string[];
                 collection: boolean;
@@ -353,6 +358,7 @@ export class BINDService extends ExtraSourceService {
     hasLinkLocalAdresses: boolean;
     hasLocationRecord: boolean;
     notify: boolean;
+    _addresses: any[];
     _trusted: any[];
     _protected: any[];
     _open: any[];
@@ -364,6 +370,8 @@ export class BINDService extends ExtraSourceService {
     expire: number;
     minimum: number;
     get soaUpdates(): number[];
+    set addresses(value: any[]);
+    get addresses(): any[];
     set protected(value: any[]);
     get protected(): any[];
     set trusted(value: any[]);
@@ -384,7 +392,16 @@ export class BINDService extends ExtraSourceService {
             access: string;
         };
     }, void, unknown>;
-    generateZoneDefs(location: any, packageData: any): Promise<void>;
+    generateForeignDefs(sources: any, packageData: any): Promise<void>;
+    generateZoneDefs(sources: any, packageData: any): Promise<void>;
+    foreignDomainZones(host: any, records: any): any;
+    get defaultRecords(): {
+        type: any;
+        key: any;
+        values: any[];
+        toString: (maxKeyLength?: number, ttl?: string) => string;
+    }[];
+    writeZones(packageData: any, configs: any): Promise<void>;
 }
 import { ExtraSourceService } from "pmcf";
 import { FileContentProvider } from "npm-pkgbuild";