pmcf 1.67.2 → 1.69.0

package/package.json

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

package/src/dns.mjs

@@ -9,6 +9,8 @@ import {
 } from "./utils.mjs";
 import { Base } from "./base.mjs";
 import { addType } from "./types.mjs";
+import { sortByPriority } from "./service.mjs";
+import { subnets } from "./subnet.mjs";
 
 const DNSServiceTypeDefinition = {
   name: "dns",
@@ -29,6 +31,7 @@ const DNSServiceTypeDefinition = {
     expire: { type: "string", collection: false, writeable: true },
     minimum: { type: "string", collection: false, writeable: true },
     forwardsTo: { type: "network", collection: true, writeable: true },
+    trusts: { type: "network", collection: true, writeable: true },
     allowedUpdates: { type: "string", collection: true, writeable: true }
   }
 };
@@ -43,6 +46,7 @@ export class DNSService extends Base {
   hasLinkLocalAdresses = true;
   notify = true;
   #forwardsTo = [];
+  #trusts = [];
 
   refresh = 36000;
   retry = 72000;
@@ -71,6 +75,14 @@ export class DNSService extends Base {
     return [this.refresh, this.retry, this.expire, this.minimum];
   }
 
+  set trusts(value) {
+    this.#trusts.push(value);
+  }
+
+  get trusts() {
+    return this.#trusts;
+  }
+
   set forwardsTo(value) {
     this.#forwardsTo.push(value);
   }
@@ -79,6 +91,15 @@ 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);
 
@@ -93,7 +114,7 @@ export class DNSService extends Base {
 
   async resolvedConfig() {
     const dnsServices = Array.from(this.findServices(DNS_SERVICE_FILTER)).sort(
-      (a, b) => a.priority - b.priority
+      sortByPriority
     );
 
     const master = dnsServices
@@ -129,27 +150,18 @@ export class DNSService extends Base {
       }
     };
 
-    const options = ["forwarders {"];
-    for (const s of this.forwardsTo) {
-      for (const dns of s.findServices(DNS_SERVICE_FILTER)) {
-        options.push(...(dns.rawAddresses.map(a=>`  ${a};`)));
-      }
-    }
-    options.push("};");
+    const options = [
+      "forwarders {",
+      ...this.forwardsToAdresses.map(a => `  ${a};`),
+      "};"
+    ];
     await writeLines(join(p1, "etc/named.d/options"), `${name}.conf`, options);
 
-    const category = [];
-
-    /*
-    const category = ["acl trusted {"];
-
-    const network = this.owner.named("LOCAL");
-    for (const subnet of network.subnets()) {
-      category.push(`${subnet.name};`);
-    }
-
-    category.push("}");
-    */
+    const category = [
+      "acl trusted {",
+      ...Array.from(subnets(this.trusts)).map(subnet => `  ${subnet.name};`),
+      "};"
+    ];
 
     await writeLines(
       join(p1, "etc/named.d/categories"),
@@ -157,7 +169,7 @@ export class DNSService extends Base {
       category
     );
 
-    if(options.length > 2 || category.length > 2) {
+    if (options.length > 2 || category.length > 2) {
       yield result;
     }
 

package/src/host.mjs

@@ -266,10 +266,54 @@ export class Host extends Base {
     if (filter) {
       for (const service of this.#services) {
         if (
-          filter.type === "*" ||
-          filter.type === service.type ||
-          filter.name === service.name
+          (filter.type === undefined || filter.type === service.type) &&
+          (filter.name === undefined || filter.name === service.name)
         ) {
+          switch (typeof filter.priority) {
+            case "number":
+              if (filter.priority !== service.priority) {
+                continue;
+              }
+              break;
+            case "string":
+              const m = filter.priority.match(/^([=><!]+)(\d+)/);
+              if (m) {
+                const priority = parseInt(m[2]);
+                switch (m[1]) {
+                  case "=":
+                    if (service.priority != priority) {
+                      continue;
+                    }
+                    break;
+                  case "!=":
+                    if (service.priority == priority) {
+                      continue;
+                    }
+                    break;
+                  case "<":
+                    if (service.priority >= priority) {
+                      continue;
+                    }
+                    break;
+                  case "<=":
+                    if (service.priority > priority) {
+                      continue;
+                    }
+                    break;
+                  case ">":
+                    if (service.priority <= priority) {
+                      continue;
+                    }
+                    break;
+                  case ">=":
+                    if (service.priority < priority) {
+                      continue;
+                    }
+                    break;
+                }
+              }
+          }
+
           yield service;
         }
       }

package/src/service.mjs

@@ -1,6 +1,9 @@
 import { Base } from "./base.mjs";
 import { addType } from "./types.mjs";
 
+
+export const sortByPriority = (a, b) => a.priority - b.priority;
+
 const ServiceTypes = {
   dns: { protocol: "udp", port: 53 },
   ldap: { protocol: "tcp", port: 389 },

package/src/subnet.mjs

@@ -75,3 +75,17 @@ export class Subnet extends Base {
     return false;
   }
 }
+
+
+export function subnets(sources) {
+  const all = new Set();
+
+  for (const owner of sources) {
+    for (const subnet of owner.subnets()) {
+      all.add(subnet);
+    }
+  }
+
+  return all;
+}
+

package/types/cluster.d.mts

@@ -142,6 +142,11 @@ export class Cluster extends Host {
                                 collection: boolean;
                                 writeable: boolean;
                             };
+                            trusts: {
+                                type: string;
+                                collection: boolean;
+                                writeable: boolean;
+                            };
                             allowedUpdates: {
                                 type: string;
                                 collection: boolean;
@@ -326,6 +331,11 @@ export class Cluster extends Host {
                                 collection: boolean;
                                 writeable: boolean;
                             };
+                            trusts: {
+                                type: string;
+                                collection: boolean;
+                                writeable: boolean;
+                            };
                             allowedUpdates: {
                                 type: string;
                                 collection: boolean;

package/types/dns.d.mts

@@ -56,6 +56,11 @@ export class DNSService extends Base {
                 collection: boolean;
                 writeable: boolean;
             };
+            trusts: {
+                type: string;
+                collection: boolean;
+                writeable: boolean;
+            };
             allowedUpdates: {
                 type: string;
                 collection: boolean;
@@ -74,8 +79,11 @@ export class DNSService extends Base {
     expire: number;
     minimum: number;
     get soaUpdates(): number[];
+    set trusts(value: any[]);
+    get trusts(): any[];
     set forwardsTo(value: any[]);
     get forwardsTo(): any[];
+    get forwardsToAdresses(): any[];
     get domains(): any[];
     resolvedConfig(): Promise<{
         DNS: string;

package/types/location.d.mts

@@ -142,6 +142,11 @@ export class Location extends Owner {
                                 collection: boolean;
                                 writeable: boolean;
                             };
+                            trusts: {
+                                type: string;
+                                collection: boolean;
+                                writeable: boolean;
+                            };
                             allowedUpdates: {
                                 type: string;
                                 collection: boolean;
@@ -326,6 +331,11 @@ export class Location extends Owner {
                                 collection: boolean;
                                 writeable: boolean;
                             };
+                            trusts: {
+                                type: string;
+                                collection: boolean;
+                                writeable: boolean;
+                            };
                             allowedUpdates: {
                                 type: string;
                                 collection: boolean;

package/types/network.d.mts

@@ -144,6 +144,11 @@ export class Network extends Owner {
                                 collection: boolean;
                                 writeable: boolean;
                             };
+                            trusts: {
+                                type: string;
+                                collection: boolean;
+                                writeable: boolean;
+                            };
                             allowedUpdates: {
                                 type: string;
                                 collection: boolean;

package/types/owner.d.mts

@@ -140,6 +140,11 @@ export class Owner extends Base {
                             collection: boolean;
                             writeable: boolean;
                         };
+                        trusts: {
+                            type: string;
+                            collection: boolean;
+                            writeable: boolean;
+                        };
                         allowedUpdates: {
                             type: string;
                             collection: boolean;

package/types/root.d.mts

@@ -146,6 +146,11 @@ export class Root extends Location {
                                     collection: boolean;
                                     writeable: boolean;
                                 };
+                                trusts: {
+                                    type: string;
+                                    collection: boolean;
+                                    writeable: boolean;
+                                };
                                 allowedUpdates: {
                                     type: string;
                                     collection: boolean;
@@ -330,6 +335,11 @@ export class Root extends Location {
                                     collection: boolean;
                                     writeable: boolean;
                                 };
+                                trusts: {
+                                    type: string;
+                                    collection: boolean;
+                                    writeable: boolean;
+                                };
                                 allowedUpdates: {
                                     type: string;
                                     collection: boolean;

package/types/service.d.mts

@@ -1,3 +1,4 @@
+export function sortByPriority(a: any, b: any): number;
 export class Service extends Base {
     static get typeDefinition(): {
         name: string;

package/types/subnet.d.mts

@@ -1,3 +1,4 @@
+export function subnets(sources: any): Set<any>;
 export class Subnet extends Base {
     static get typeDefinition(): {
         name: string;