pmcf 1.98.2 → 1.99.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pmcf",
-  "version": "1.98.2",
+  "version": "1.99.1",
   "publishConfig": {
     "access": "public"
   },
@@ -43,7 +43,7 @@
     "pkg-dir": "^8.0.0"
   },
   "devDependencies": {
-    "@types/node": "^22.13.13",
+    "@types/node": "^22.13.14",
     "ava": "^6.2.0",
     "c8": "^10.1.3",
     "documentation": "^14.0.3",

package/src/base.mjs

@@ -179,9 +179,11 @@ export class Base {
           if (value instanceof property.type.clazz) {
             assign(property, value);
           } else {
+            const factory = property.type.factoryFor?.(value) || property.type.clazz;
+
             assign(
               property,
-              new property.type.clazz(this.ownerFor(property, value), value)
+              new factory(this.ownerFor(property, value), value)
             );
           }
           break;

package/src/host-utils.mjs

@@ -25,6 +25,11 @@ export async function generateNetworkDefs(host, packageData) {
   const networkDir = join(packageData.dir, "etc/systemd/network");
 
   for (const ni of host.networkInterfaces.values()) {
+    switch (ni.kind) {
+      case "loopback":
+        continue;
+    }
+
     if (ni.name !== "eth0" && ni.hwaddr) {
       await writeLines(networkDir, `${ni.name}.link`, [
         sectionLines("Match", { MACAddress: ni.hwaddr }),
@@ -46,7 +51,7 @@ export async function generateNetworkDefs(host, packageData) {
 
     switch (ni.kind) {
       case "ethernet":
-      case "wifi":
+      case "wlan":
         const routeSectionExtra = ni.destination
           ? { Destination: ni.destination }
           : { Gateway: ni.gatewayAddress };

package/src/location.mjs

@@ -68,7 +68,7 @@ export class Location extends Owner {
     await writeLines(
       join(dir, "etc/systemd/resolved.conf.d"),
       `${this.name}.conf`,
-      sectionLines(...this.dns.systemdConfig)
+      sectionLines(...this.findService({type: "dns"}).systemdConfig)
     );
 
     await writeLines(
@@ -84,7 +84,7 @@ export class Location extends Owner {
     await writeLines(
       join(dir, "etc/systemd/timesyncd.conf.d"),
       `${this.name}.conf`,
-      sectionLines(...this.ntp.systemdConfig)
+      sectionLines(...this.findService({type: "ntp"}).systemdConfig)
     );
 
     const locationDir = join(dir, "etc", "location");

package/src/module.mjs

@@ -1,8 +1,8 @@
 export * from "./base.mjs";
 export * from "./service.mjs";
-export * from "./dns.mjs";
-export * from "./ntp.mjs";
-export * from "./dhcp.mjs";
+export * from "./services/dns.mjs";
+export * from "./services/ntp.mjs";
+export * from "./services/dhcp.mjs";
 export * from "./cluster.mjs";
 export * from "./owner.mjs";
 export * from "./location.mjs";

package/src/owner.mjs

@@ -2,9 +2,6 @@ import { asIterator, normalizeCIDR } from "./utils.mjs";
 import { Base } from "./base.mjs";
 import { Subnet } from "./subnet.mjs";
 import { addType, types } from "./types.mjs";
-import { DNSService } from "./dns.mjs";
-import { NTPService } from "./ntp.mjs";
-import { DHCPService } from "./dhcp.mjs";
 
 const OwnerTypeDefinition = {
   name: "owner",
@@ -16,21 +13,6 @@ const OwnerTypeDefinition = {
     hosts: { type: "host", collection: true, writeable: true },
     clusters: { type: "cluster", collection: true, writeable: true },
     subnets: { type: Subnet.typeDefinition, collection: true, writeable: true },
-    dns: {
-      type: DNSService.typeDefinition,
-      collection: false,
-      writeable: true
-    },
-    ntp: {
-      type: NTPService.typeDefinition,
-      collection: false,
-      writeable: true
-    },
-    dhcp: {
-      type: DHCPService.typeDefinition,
-      collection: false,
-      writeable: true
-    },
 
     country: { type: "string", collection: false, writeable: true },
     domain: { type: "string", collection: false, writeable: true },
@@ -69,10 +51,6 @@ export class Owner extends Base {
         }
       }
 
-      this.dns?._traverse(...args);
-      this.ntp?._traverse(...args);
-      this.dhcp?._traverse(...args);
-
       return true;
     }
 

package/src/service.mjs

@@ -8,8 +8,10 @@ import {
   dnsFormatParameters,
   dnsMergeParameters
 } from "./dns-utils.mjs";
+import { DHCPService, DNSService, NTPService } from "./module.mjs";
 
 const ServiceTypes = {
+  ntp: { protocol: "udp", port: 123, tls: false },
   dns: { protocol: "udp", port: 53, tls: false },
   ldap: { protocol: "tcp", port: 389, tls: false },
   ldaps: { protocol: "tcp", port: 636, tls: true },
@@ -46,18 +48,36 @@ const ServiceTypes = {
       parameters: {
         sys: "waMa=0",
         adVF: "0x100",
-        dk0: "adVN=MF-TM-999",
-      //  adVF: "0x82"
+        dk0: "adVN=MF-TM-999"
+        //  adVF: "0x82"
       }
     }
   }
 };
 
-const ServiceTypeDefinition = {
+export const ServiceTypeDefinition = {
   name: "service",
   owners: ["host", "cluster"],
   priority: 0.4,
   extends: Base.typeDefinition,
+  factoryFor(value) {
+    const type = value.type || value.name;
+
+    if (type === "dns") {
+      delete value.type;
+      return DNSService;
+    }
+    if (type === "ntp") {
+      delete value.type;
+      return NTPService;
+    }
+    if (type === "dhcp") {
+      delete value.type;
+      return DHCPService;
+    }
+
+    return Service;
+  },
   properties: {
     ...networkAddressProperties,
     ipAddresses: { type: "string", collection: true, writeable: true },
@@ -126,6 +146,11 @@ export class Service extends Base {
     return this;
   }
 
+  get network()
+  {
+    return this.server.network;
+  }
+  
   get server() {
     return this.owner;
   }

package/src/{dhcp.mjs → services/dhcp.mjs}

@@ -1,18 +1,21 @@
 import { join } from "node:path";
 import { FileContentProvider } from "npm-pkgbuild";
-import { Base } from "./base.mjs";
-import { addType } from "./types.mjs";
-import { writeLines } from "./utils.mjs";
-import { serviceAddresses } from "./service.mjs";
+import {
+  Service,
+  ServiceTypeDefinition,
+  serviceAddresses
+} from "../service.mjs";
+import { addType } from "../types.mjs";
+import { writeLines } from "../utils.mjs";
 
 const DHCPServiceTypeDefinition = {
   name: "dhcp",
-  owners: ["location", "owner", "network", "cluster", "root"],
+  owners: ServiceTypeDefinition.owners,
   priority: 0.1,
   properties: {}
 };
 
-export class DHCPService extends Base {
+export class DHCPService extends Service {
   static {
     addType(this);
   }
@@ -22,13 +25,12 @@ export class DHCPService extends Base {
   }
 
   constructor(owner, data) {
-    if (!data.name) {
-      data.name = DHCPServiceTypeDefinition.name; // TODO
-    }
     super(owner, data);
     this.read(data, DHCPServiceTypeDefinition);
+  }
 
-    owner.addObject(this);
+  get type() {
+    return DHCPServiceTypeDefinition.name;
   }
 
   async *preparePackages(dir) {
@@ -41,7 +43,8 @@ export class DHCPService extends Base {
         name: `kea-${name}`,
         description: `kea definitions for ${this.fullName}`,
         access: "private",
-        dependencies: ["kea"]
+        dependencies: ["kea"],
+        replaces: ["kea-sw"] // TODO remove
       }
     };
 
@@ -131,7 +134,7 @@ export class DHCPService extends Base {
     const hwmap = new Map();
     const hostNames = new Set();
 
-    for await (const { networkInterface } of this.owner.networkAddresses()) {
+    for await (const { networkInterface } of this.network.networkAddresses()) {
       if (networkInterface.hwaddr) {
         if (!hostNames.has(networkInterface.hostName)) {
           hwmap.set(networkInterface.hwaddr, networkInterface);

package/src/{dns.mjs → services/dns.mjs}

@@ -6,16 +6,19 @@ import {
   isIPv6Address,
   normalizeIPAddress,
   isLinkLocal
-} from "./utils.mjs";
-import { DNSRecord, dnsFullName } from "./dns-utils.mjs";
-import { Base } from "./base.mjs";
-import { addType } from "./types.mjs";
-import { serviceAddresses } from "./service.mjs";
-import { subnets } from "./subnet.mjs";
+} from "../utils.mjs";
+import { DNSRecord, dnsFullName } from "../dns-utils.mjs";
+import { addType } from "../types.mjs";
+import {
+  Service,
+  ServiceTypeDefinition,
+  serviceAddresses
+} from "../service.mjs";
+import { subnets } from "../subnet.mjs";
 
 const DNSServiceTypeDefinition = {
   name: "dns",
-  owners: ["location", "owner", "network", "cluster", "root"],
+  owners: ServiceTypeDefinition.owners,
   priority: 0.1,
   properties: {
     source: { type: "network", collection: true, writeable: true },
@@ -58,7 +61,7 @@ function addressesStatement(prefix, objects, generateEmpty = false) {
   return [];
 }
 
-export class DNSService extends Base {
+export class DNSService extends Service {
   allowedUpdates = [];
   recordTTL = "1W";
   hasSVRRecords = true;
@@ -85,13 +88,12 @@ export class DNSService extends Base {
   }
 
   constructor(owner, data) {
-    if (!data.name) {
-      data.name = DNSServiceTypeDefinition.name; // TODO
-    }
     super(owner, data);
     this.read(data, DNSServiceTypeDefinition);
+  }
 
-    owner.addObject(this);
+  get type() {
+    return DNSServiceTypeDefinition.name;
   }
 
   get soaUpdates() {
@@ -252,7 +254,9 @@ async function generateZoneDefs(dns, packageData) {
 
   const configs = [];
 
-  for (const host of dns.owner.hosts()) {
+  const location = dns.location;
+
+  for (const host of location.hosts()) {
     for (const domain of host.foreignDomainNames) {
       const zone = {
         id: domain,
@@ -324,7 +328,7 @@ async function generateZoneDefs(dns, packageData) {
       subnet,
       networkInterface,
       domainNames
-    } of dns.owner.networkAddresses()) {
+    } of location.networkAddresses()) {
       const host = networkInterface.host;
       if (
         !addresses.has(address) &&
@@ -379,12 +383,12 @@ async function generateZoneDefs(dns, packageData) {
 
         for (const service of host.findServices()) {
           //for (const domainName of domainNames) {
-            for (const record of service.dnsRecordsForDomainName(
-              host.domainName,
-              dns.hasSVRRecords
-            )) {
-              zone.records.add(record);
-            }
+          for (const record of service.dnsRecordsForDomainName(
+            host.domainName,
+            dns.hasSVRRecords
+          )) {
+            zone.records.add(record);
+          }
           //}
         }
       }

package/src/{ntp.mjs → services/ntp.mjs}

@@ -1,10 +1,13 @@
-import { Base } from "./base.mjs";
-import { addType } from "./types.mjs";
-import { serviceAddresses } from "./service.mjs";
+import { addType } from "../types.mjs";
+import {
+  Service,
+  ServiceTypeDefinition,
+  serviceAddresses
+} from "../service.mjs";
 
 const NTPServiceTypeDefinition = {
   name: "ntp",
-  owners: ["location", "owner", "network", "cluster", "root"],
+  owners: ServiceTypeDefinition.owners,
   priority: 0.1,
   properties: {
     source: { type: "network", collection: true, writeable: true }
@@ -13,7 +16,7 @@ const NTPServiceTypeDefinition = {
 
 const NTP_SERVICE_FILTER = { type: NTPServiceTypeDefinition.name };
 
-export class NTPService extends Base {
+export class NTPService extends Service {
   #source = [];
 
   static {
@@ -25,13 +28,12 @@ export class NTPService extends Base {
   }
 
   constructor(owner, data) {
-    if (!data.name) {
-      data.name = NTPServiceTypeDefinition.name; // TODO
-    }
     super(owner, data);
     this.read(data, NTPServiceTypeDefinition);
+  }
 
-    owner.addObject(this);
+  get type() {
+    return NTPServiceTypeDefinition.name;
   }
 
   set source(value) {

package/types/cluster.d.mts

@@ -91,118 +91,6 @@ export class Cluster extends Host {
                     collection: boolean;
                     writeable: boolean;
                 };
-                dns: {
-                    type: {
-                        name: string;
-                        owners: string[];
-                        priority: number;
-                        properties: {
-                            source: {
-                                type: string;
-                                collection: boolean;
-                                writeable: boolean;
-                            };
-                            trusted: {
-                                type: string;
-                                collection: boolean;
-                                writeable: boolean;
-                            };
-                            protected: {
-                                type: string;
-                                collection: boolean;
-                                writeable: boolean;
-                            };
-                            open: {
-                                type: string;
-                                collection: boolean;
-                                writeable: boolean;
-                            };
-                            hasSVRRecords: {
-                                type: string;
-                                collection: boolean;
-                                writeable: boolean;
-                            };
-                            hasCatalog: {
-                                type: string;
-                                collection: boolean;
-                                writeable: boolean;
-                            };
-                            hasLinkLocalAdresses: {
-                                type: string;
-                                collection: boolean;
-                                writeable: boolean;
-                            };
-                            notify: {
-                                type: string;
-                                collection: boolean;
-                                writeable: boolean;
-                            };
-                            recordTTL: {
-                                type: string;
-                                collection: boolean;
-                                writeable: boolean;
-                            };
-                            serial: {
-                                type: string;
-                                collection: boolean;
-                                writeable: boolean;
-                            };
-                            refresh: {
-                                type: string;
-                                collection: boolean;
-                                writeable: boolean;
-                            };
-                            retry: {
-                                type: string;
-                                collection: boolean;
-                                writeable: boolean;
-                            };
-                            expire: {
-                                type: string;
-                                collection: boolean;
-                                writeable: boolean;
-                            };
-                            minimum: {
-                                type: string;
-                                collection: boolean;
-                                writeable: boolean;
-                            };
-                            allowedUpdates: {
-                                type: string;
-                                collection: boolean;
-                                writeable: boolean;
-                            };
-                        };
-                    };
-                    collection: boolean;
-                    writeable: boolean;
-                };
-                ntp: {
-                    type: {
-                        name: string;
-                        owners: string[];
-                        priority: number;
-                        properties: {
-                            source: {
-                                type: string;
-                                collection: boolean;
-                                writeable: boolean;
-                            };
-                        };
-                    };
-                    collection: boolean;
-                    writeable: boolean;
-                };
-                dhcp: {
-                    type: {
-                        name: string;
-                        owners: string[];
-                        priority: number;
-                        properties: {};
-                    };
-                    collection: boolean;
-                    writeable: boolean;
-                };
                 country: {
                     type: string;
                     collection: boolean;