pmcf 2.2.0 → 2.3.0

package/package.json

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

package/src/dns-utils.mjs

@@ -31,7 +31,7 @@ export function DNSRecord(key, type, ...values) {
 
   return {
     key,
-    toString: (maxKeyLength, ttl) =>
+    toString: (maxKeyLength = 0, ttl = "1W") =>
       `${key.padEnd(maxKeyLength, " ")} ${ttl} IN ${type.padEnd(
         5,
         " "

package/src/service.mjs

@@ -1,6 +1,6 @@
 import { Base } from "./base.mjs";
 import { addType } from "./types.mjs";
-import { asArray,isLocalhost } from "./utils.mjs";
+import { asArray, isLocalhost } from "./utils.mjs";
 import { networkAddressProperties } from "./network-support.mjs";
 import {
   DNSRecord,
@@ -11,38 +11,43 @@ import {
 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 },
-  http: { protocol: "tcp", port: 80, tls: false },
+  ntp: { endpoints: [{ protocol: "udp", port: 123, tls: false }] },
+  dns: { endpoints: [{ protocol: "udp", port: 53, tls: false }] },
+  ldap: { endpoints: [{ protocol: "tcp", port: 389, tls: false }] },
+  ldaps: { endpoints: [{ protocol: "tcp", port: 636, tls: true }] },
+  http: { endpoints: [{ protocol: "tcp", port: 80, tls: false }] },
   https: {
-    protocol: "tcp",
-    port: 443,
-    tls: true,
+    endpoints: [{ protocol: "tcp", port: 443, tls: true }],
     dnsRecord: { type: "HTTPS", parameters: { alpn: "h2" } }
   },
   http3: {
     type: "https",
-    protocol: "tcp",
-    port: 443,
-    tls: true,
+    endpoints: [{ protocol: "tcp", port: 443, tls: true }],
     dnsRecord: {
       type: "HTTPS",
       parameters: { "no-default-alpn": undefined, alpn: "h3" }
     }
   },
-  rtsp: { protocol: "tcp", port: 554, tls: false },
-  smtp: { protocol: "tcp", port: 25, tls: false, dnsRecord: { type: "MX" } },
-  ssh: { protocol: "tcp", port: 22, tls: false },
-  imap: { protocol: "tcp", port: 143, tls: false },
-  imaps: { protocol: "tcp", port: 993, tls: true },
-  dhcp: { tls: false },
-  smb: { protocol: "tcp", port: 445, tls: false },
+  rtsp: { endpoints: [{ protocol: "tcp", port: 554, tls: false }] },
+  smtp: {
+    endpoints: [{ protocol: "tcp", port: 25, tls: false }],
+    dnsRecord: { type: "MX" }
+  },
+  ssh: { endpoints: [{ protocol: "tcp", port: 22, tls: false }] },
+  imap: { endpoints: [{ protocol: "tcp", port: 143, tls: false }] },
+  imaps: { endpoints: [{ protocol: "tcp", port: 993, tls: true }] },
+  dhcp: { endpoints: [{ port: 547, tls: false }] },
+  "dhcpv6-client": {
+    endpoints: [
+      { protocol: "tcp", port: 546, tls: false },
+      { protocol: "udp", port: 546, tls: false }
+    ]
+  },
+  "dhcpv6-server": { endpoints: [{ port: 547, tls: false }] },
+  smb: { endpoints: [{ protocol: "tcp", port: 445, tls: false }] },
   timemachine: {
     type: "adisk",
-    protocol: "tcp",
-    tls: false,
+    endpoints: [{ protocol: "tcp", tls: false }],
     dnsRecord: {
       type: "TXT",
       parameters: {
@@ -86,7 +91,6 @@ export const ServiceTypeDefinition = {
     alias: { type: "string", collection: false, writeable: true },
     type: { type: "string", collection: false, writeable: true },
     weight: { type: "number", collection: false, writeable: true },
-    srvPrefix: { type: "string", collection: false, writeable: false },
     tls: { type: "string", collection: false, writeable: false },
     systemd: { type: "string", collection: true, writeable: true }
   }
@@ -145,12 +149,22 @@ export class Service extends Base {
     return this.rawAddresses.map(a => `${a}:${this.port}`);
   }
 
+  get endpoints() {
+    if (this._port !== undefined) {
+      return [
+        { protocol: this.protocol, address: this.rawAddress, port: this._port }
+      ];
+    }
+
+    return ServiceTypes[this.type]?.endpoints || [];
+  }
+
   set port(value) {
     this._port = value;
   }
 
   get port() {
-    return this._port || ServiceTypes[this.type]?.port;
+    return this._port || ServiceTypes[this.type]?.endpoints[0].port;
   }
 
   set weight(value) {
@@ -178,7 +192,7 @@ export class Service extends Base {
   }
 
   get protocol() {
-    return ServiceTypes[this.type]?.protocol;
+    return ServiceTypes[this.type]?.endpoints[0].protocol;
   }
 
   get tls() {
@@ -189,30 +203,29 @@ export class Service extends Base {
     return this._systemd;
   }
 
-  get srvPrefix() {
-    const st = ServiceTypes[this.type];
-    if (st?.protocol) {
-      return `_${st.type || this.type}._${st.protocol}`;
-    }
-  }
-
   dnsRecordsForDomainName(domainName, hasSVRRecords) {
     const records = [];
     if (this.priority <= 1 && this.alias) {
       records.push(DNSRecord(this.alias, "CNAME", dnsFullName(domainName)));
     }
 
-    if (hasSVRRecords && this.srvPrefix) {
-      records.push(
-        DNSRecord(
-          dnsFullName(`${this.srvPrefix}.${domainName}`),
-          "SRV",
-          this.priority || 10,
-          this.weight,
-          this.port,
-          dnsFullName(this.domainName)
-        )
-      );
+    if (hasSVRRecords) {
+      for (const ep of this.endpoints.filter(e => e.protocol)) {
+        records.push(
+          DNSRecord(
+            dnsFullName(
+              `_${ServiceTypes[this.type]?.type || this.type}._${
+                ep.protocol
+              }.${domainName}`
+            ),
+            "SRV",
+            this.priority === undefined ? 10 : this.priority,
+            this.weight,
+            ep.port,
+            dnsFullName(this.domainName)
+          )
+        );
+      }
     }
 
     const dnsRecord = ServiceTypes[this.type]?.dnsRecord;
@@ -234,7 +247,7 @@ export class Service extends Base {
           DNSRecord(
             dnsFullName(domainName),
             dnsRecord.type,
-            this.priority || 10,
+            this.priority === undefined ? 10 : this.priority,
             ".",
             dnsFormatParameters(parameters)
           )
@@ -256,12 +269,13 @@ export function serviceAddresses(
   sources,
   filter,
   addressType = "rawAddresses",
-  addressFilter = a=>!isLocalhost(a)
+  addressFilter = a => !isLocalhost(a)
 ) {
   return asArray(sources)
     .map(ft => Array.from(ft.findServices(filter)))
     .flat()
     .sort(sortByPriority)
     .map(s => s[addressType])
-    .flat().filter(addressFilter);
+    .flat()
+    .filter(addressFilter);
 }

package/types/dns-utils.d.mts

@@ -1,7 +1,7 @@
 export function dnsFullName(name: any): any;
 export function DNSRecord(key: any, type: any, ...values: any[]): {
     key: any;
-    toString: (maxKeyLength: any, ttl: any) => string;
+    toString: (maxKeyLength?: number, ttl?: string) => string;
 };
 export function dnsFormatParameters(parameters: any): string;
 export function dnsMergeParameters(a: any, b: any): {

package/types/extra-source-service.d.mts

@@ -98,11 +98,6 @@ export class ExtraSourceService extends Service {
                     collection: boolean;
                     writeable: boolean;
                 };
-                srvPrefix: {
-                    type: string;
-                    collection: boolean;
-                    writeable: boolean;
-                };
                 tls: {
                     type: string;
                     collection: boolean;

package/types/service.d.mts

@@ -83,11 +83,6 @@ export namespace ServiceTypeDefinition {
             collection: boolean;
             writeable: boolean;
         };
-        srvPrefix: {
-            type: string;
-            collection: boolean;
-            writeable: boolean;
-        };
         tls: {
             type: string;
             collection: boolean;
@@ -209,11 +204,6 @@ export class Service extends Base {
                 collection: boolean;
                 writeable: boolean;
             };
-            srvPrefix: {
-                type: string;
-                collection: boolean;
-                writeable: boolean;
-            };
             tls: {
                 type: string;
                 collection: boolean;
@@ -264,6 +254,7 @@ export class Service extends Base {
     get rawAddress(): any;
     set ipAddresses(value: any);
     get addresses(): any;
+    get endpoints(): any;
     set port(value: any);
     get port(): any;
     set weight(value: any);
@@ -273,10 +264,9 @@ export class Service extends Base {
     get protocol(): any;
     get tls(): any;
     get systemdServices(): any;
-    get srvPrefix(): string;
     dnsRecordsForDomainName(domainName: any, hasSVRRecords: any): {
         key: any;
-        toString: (maxKeyLength: any, ttl: any) => string;
+        toString: (maxKeyLength?: number, ttl?: string) => string;
     }[];
 }
 export function sortByPriority(a: any, b: any): number;

package/types/services/dhcp.d.mts

@@ -85,11 +85,6 @@ export class DHCPService extends Service {
                     collection: boolean;
                     writeable: boolean;
                 };
-                srvPrefix: {
-                    type: string;
-                    collection: boolean;
-                    writeable: boolean;
-                };
                 tls: {
                     type: string;
                     collection: boolean;

package/types/services/dns.d.mts

@@ -90,11 +90,6 @@ export class DNSService extends ExtraSourceService {
                         collection: boolean;
                         writeable: boolean;
                     };
-                    srvPrefix: {
-                        type: string;
-                        collection: boolean;
-                        writeable: boolean;
-                    };
                     tls: {
                         type: string;
                         collection: boolean;

package/types/services/ntp.d.mts

@@ -88,11 +88,6 @@ export class NTPService extends ExtraSourceService {
                         collection: boolean;
                         writeable: boolean;
                     };
-                    srvPrefix: {
-                        type: string;
-                        collection: boolean;
-                        writeable: boolean;
-                    };
                     tls: {
                         type: string;
                         collection: boolean;