pmcf 1.70.0 → 1.72.0

package/package.json

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

package/src/dns.mjs

@@ -9,7 +9,7 @@ import {
 } from "./utils.mjs";
 import { Base } from "./base.mjs";
 import { addType } from "./types.mjs";
-import { sortByPriority } from "./service.mjs";
+import { serviceAddresses } from "./service.mjs";
 import { subnets } from "./subnet.mjs";
 
 const DNSServiceTypeDefinition = {
@@ -91,15 +91,6 @@ export class DNSService extends Base {
     return this.#forwardsTo;
   }
 
-  get forwardsToAdresses() {
-    return this.forwardsTo
-      .map(ft => Array.from(ft.findServices(DNS_SERVICE_FILTER)))
-      .flat()
-      .sort(sortByPriority)
-      .map(s => s.rawAddresses)
-      .flat();
-  }
-
   *findServices(filter) {
     yield* this.owner.findServices(filter);
 
@@ -113,22 +104,15 @@ export class DNSService extends Base {
   }
 
   async resolvedConfig() {
-    const dnsServices = Array.from(this.findServices(DNS_SERVICE_FILTER)).sort(
-      sortByPriority
-    );
-
-    const master = dnsServices
-      .filter(s => s.priority < 10)
-      .map(s => s.rawAddresses)
-      .flat();
-    const fallback = dnsServices
-      .filter(s => s.priority >= 10)
-      .map(s => s.rawAddresses)
-      .flat();
-
     return {
-      DNS: master.join(" "),
-      FallbackDNS: fallback.join(" "),
+      DNS: serviceAddresses(this, {
+        ...DNS_SERVICE_FILTER,
+        priority: "<10"
+      }).join(" "),
+      FallbackDNS: serviceAddresses(this, {
+        ...DNS_SERVICE_FILTER,
+        priority: ">=10"
+      }).join(" "),
       Domains: this.domains.join(" "),
       DNSSEC: "no",
       MulticastDNS: "yes",
@@ -152,7 +136,9 @@ export class DNSService extends Base {
 
     const options = [
       "forwarders {",
-      ...this.forwardsToAdresses.map(a => `  ${a};`),
+      ...serviceAddresses(this.forwardsTo, DNS_SERVICE_FILTER).map(
+        a => `  ${a};`
+      ),
       "};"
     ];
     await writeLines(join(p1, "etc/named.d/options"), `${name}.conf`, options);

package/src/filter.mjs

@@ -0,0 +1,79 @@
+export function* objectFilter(type, objects, filter) {
+  if (filter) {
+    advance: for (const object of objects) {
+      const filterString = key => {
+        if (filter[key] === undefined) {
+          return true;
+        }
+        if (filter[key] === object[key]) {
+          return true;
+        }
+
+        for (const value of filter[key].split("|")) {
+          if (object[key] === value) {
+            return true;
+          }
+        }
+
+        return false;
+      };
+
+      const filterNumber = key => {
+        switch (typeof filter[key]) {
+          case "undefined":
+            return true;
+          case "number":
+            return filter[key] === object[key];
+          case "string":
+            const m = filter[key].match(/^([=><!]+)(\d+)/);
+            if (m) {
+              const value = parseInt(m[2]);
+              switch (m[1]) {
+                case "=":
+                  return object[key] === value;
+                case "!=":
+                  return object[key] !== value;
+                case "<":
+                  return object[key] < value;
+                case "<=":
+                  return object[key] <= value;
+                case ">":
+                  return object[key] > value;
+                case ">=":
+                  return object[key] >= value;
+              }
+            }
+        }
+        return false;
+      };
+      for (let t = type; t; t = t.extends) {
+        for (const property of Object.values(t.properties)) {
+          switch (property.type) {
+            case "boolean":
+              if (
+                filter[property.name] !== undefined &&
+                filter[property.name] != object[property.name]
+              ) {
+                continue advance;
+              }
+              break;
+
+            case "number":
+              if (!filterNumber(property.name)) {
+                continue advance;
+              }
+              break;
+            case "string":
+              if (!filterString(property.name)) {
+                continue advance;
+              }
+              break;
+          }
+        }
+      }
+      yield object;
+    }
+  } else {
+    yield* objects;
+  }
+}

package/src/host.mjs

@@ -11,8 +11,8 @@ import {
   formatCIDR,
   hasWellKnownSubnet
 } from "./utils.mjs";
-import { serviceFilter } from "./service.mjs";
-import { addType } from "./types.mjs";
+import { objectFilter } from "./filter.mjs";
+import { addType, types } from "./types.mjs";
 import {
   generateNetworkDefs,
   generateMachineInfo,
@@ -264,7 +264,7 @@ export class Host extends Base {
   }
 
   *findServices(filter) {
-    yield* serviceFilter(this.#services, filter);
+    yield* objectFilter(types.service, this.#services, filter);
   }
 
   typeNamed(typeName, name) {

package/src/service.mjs

@@ -1,5 +1,6 @@
 import { Base } from "./base.mjs";
 import { addType } from "./types.mjs";
+import { asArray } from "./utils.mjs";
 
 const ServiceTypes = {
   dns: { protocol: "udp", port: 53 },
@@ -27,7 +28,8 @@ const ServiceTypeDefinition = {
     type: { type: "string", collection: false, writeable: true },
     master: { type: "boolean", collection: false, writeable: true },
     priority: { type: "number", collection: false, writeable: true },
-    weight: { type: "number", collection: false, writeable: true }
+    weight: { type: "number", collection: false, writeable: true },
+    srvPrefix: { type: "string", collection: false, writeable: false }
   }
 };
 
@@ -166,66 +168,15 @@ export class Service extends Base {
 
 export const sortByPriority = (a, b) => a.priority - b.priority;
 
-export function* serviceFilter(services, filter) {
-  if (filter) {
-    for (const service of services) {
-      const filterString = key => {
-        if (filter[key] === undefined) {
-          return true;
-        }
-        if (filter[key] === service[key]) {
-          return true;
-        }
-
-        for(const value of filter[key].split('|')) {
-          if(service[key] === value) { return true; }
-        }
-
-        return false;
-      };
-
-      const filterNumber = key => {
-        switch (typeof filter[key]) {
-          case "undefined":
-            return true;
-          case "number":
-            return filter[key] === service[key];
-          case "string":
-            const m = filter[key].match(/^([=><!]+)(\d+)/);
-            if (m) {
-              const value = parseInt(m[2]);
-              switch (m[1]) {
-                case "=":
-                  return service[key] === value;
-                case "!=":
-                  return service[key] !== value;
-                case "<":
-                  return service[key] < value;
-                case "<=":
-                  return service[key] <= value;
-                case ">":
-                  return service[key] > value;
-                case ">=":
-                  return service[key] >= value;
-              }
-            }
-        }
-        return false;
-      };
-
-      if (
-        filterString("type") &&
-        filterString("name") &&
-        filterString("protocol") &&
-        filterString("alias") &&
-        filterNumber("priority") &&
-        filterNumber("weight") &&
-        filterNumber("port")
-      ) {
-        yield service;
-      }
-    }
-  } else {
-    yield* services;
-  }
+export function serviceAddresses(
+  sources,
+  filter,
+  addressType = "rawAddresses"
+) {
+  return asArray(sources)
+    .map(ft => Array.from(ft.findServices(filter)))
+    .flat()
+    .sort(sortByPriority)
+    .map(s => s[addressType])
+    .flat();
 }

package/types/dns.d.mts

@@ -83,7 +83,6 @@ export class DNSService extends Base {
     get trusted(): any[];
     set forwardsTo(value: any[]);
     get forwardsTo(): any[];
-    get forwardsToAdresses(): any[];
     get domains(): any[];
     resolvedConfig(): Promise<{
         DNS: string;

package/types/filter.d.mts

@@ -0,0 +1 @@
+export function objectFilter(type: any, objects: any, filter: any): Generator<any, void, any>;

package/types/service.d.mts

@@ -1,4 +1,4 @@
-export function serviceFilter(services: any, filter: any): Generator<any, void, any>;
+export function serviceAddresses(sources: any, filter: any, addressType?: string): any[];
 export class Service extends Base {
     static get typeDefinition(): {
         name: string;
@@ -82,6 +82,11 @@ export class Service extends Base {
                 collection: boolean;
                 writeable: boolean;
             };
+            srvPrefix: {
+                type: string;
+                collection: boolean;
+                writeable: boolean;
+            };
         };
     };
     alias: any;