pmcf 2.33.7 → 2.35.0

package/package.json

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

package/src/endpoint.mjs

@@ -17,6 +17,10 @@ export class Endpoint {
     return this.networkAddress.networkInterface.hostName;
   }
 
+  get domainName() {
+    return this.networkAddress.networkInterface.domainName;
+  }
+
   get address() {
     return this.networkAddress.address;
   }
@@ -29,3 +33,23 @@ export class Endpoint {
     return this.networkAddress.networkInterface;
   }
 }
+
+export class DomainNameEndpoint {
+  constructor(service, domainName, data) {
+    this.service = service;
+    this.domainName = domainName;
+    Object.assign(this, data);
+  }
+
+  get networkInterface() {
+    return {};
+  }
+
+  get address() {
+    return this.domainName;
+  }
+
+  toString() {
+    return `${this.address}[${this.port}]`;
+  }
+}

package/src/host.mjs

@@ -3,7 +3,12 @@ import { join } from "node:path";
 import { FileContentProvider } from "npm-pkgbuild";
 import { ServiceOwner, Base } from "pmcf";
 import { networkAddressProperties, addresses } from "./network-support.mjs";
-import { domainFromDominName, domainName } from "./utils.mjs";
+import {
+  domainFromDominName,
+  domainName,
+  writeLines,
+  sectionLines
+} from "./utils.mjs";
 import { objectFilter } from "./filter.mjs";
 import { addType, types } from "./types.mjs";
 import { loadHooks } from "./hooks.mjs";
@@ -484,6 +489,13 @@ export class Host extends ServiceOwner {
     await generateMachineInfo(this, packageData);
     await generateKnownHosts(this.owner.hosts(), join(dir, "root", ".ssh"));
 
+    for (const service of this.services) {
+      if (service.systemdConfig) {
+        const { name, content } = service.systemdConfig(this.name);
+        await writeLines(dir, name, sectionLines(...content));
+      }
+    }
+
     yield packageData;
   }
 }

package/src/location.mjs

@@ -1,7 +1,6 @@
 import { FileContentProvider } from "npm-pkgbuild";
-import { Owner } from "./owner.mjs";
+import { Owner } from "pmcf";
 import { addType } from "./types.mjs";
-import { writeLines, sectionLines } from "./utils.mjs";
 import { loadHooks } from "./hooks.mjs";
 
 const LocationTypeDefinition = {
@@ -69,21 +68,6 @@ export class Location extends Owner {
       }
     };
 
-    const configs = [
-      { type: "dns" },
-      { type: "systemd-timesyncd" },
-      { type: "systemd-journal" }
-    ];
-
-    for (const cfg of configs) {
-      const service = this.findService(cfg);
-
-      if (service) {
-        const { name, content } = service.systemdConfig(this.name);
-        await writeLines(dir, name, sectionLines(...content));
-      }
-    }
-
     yield packageData;
   }
 }

package/src/module.mjs

@@ -15,10 +15,12 @@ export * from "./network-interfaces/wlan.mjs";
 export * from "./network-interfaces/wireguard.mjs";
 export * from "./host.mjs";
 export * from "./service.mjs";
+export * from "./extra-source-service.mjs";
 export * from "./endpoint.mjs";
 export * from "./services/dns.mjs";
 export * from "./services/ntp.mjs";
 export * from "./services/dhcp.mjs";
 export * from "./services/systemd-journal.mjs";
 export * from "./services/systemd-timesyncd.mjs";
+export * from "./services/systemd-resolved.mjs";
 export * from "./types.mjs";

package/src/network-interfaces/skeleton.mjs

@@ -42,6 +42,10 @@ export class SkeletonNetworkInterface extends ServiceOwner {
     return this;
   }
 
+  get domainName() {
+    return this.host?.domainName;
+  }
+
   get domainNames() {
     return new Set();
   }

package/src/service.mjs

@@ -1,5 +1,4 @@
-import { isLocalhost } from "ip-utilties";
-import { Base, Host, Endpoint } from "pmcf";
+import { Base, Host, Endpoint, DomainNameEndpoint } from "pmcf";
 import { addType } from "./types.mjs";
 import { asArray } from "./utils.mjs";
 import { networkAddressProperties } from "./network-support.mjs";
@@ -199,7 +198,7 @@ export class Service extends Base {
       }
     ];
 
-    const result = [...this.host.networkAddresses()]
+    let result = [...this.host.networkAddresses()]
       .map(na =>
         data.map(
           d =>
@@ -211,6 +210,12 @@ export class Service extends Base {
       )
       .flat();
 
+    if (result.length === 0) {
+      result = data.map(
+        d => new DomainNameEndpoint(this, this.domainName, { ...d, ...local })
+      );
+    }
+
     return filter ? result.filter(filter) : result;
   }
 
@@ -322,26 +327,15 @@ export class Service extends Base {
 
 export const sortByPriority = (a, b) => a.priority - b.priority;
 
-export function serviceAddresses(
-  sources,
-  filter,
-  addressType = "addresses",
-  addressFilter = a => !isLocalhost(a)
-) {
-  return asArray(sources)
-    .map(ft => Array.from(ft.findServices(filter)))
+export function serviceEndpoints(sources, options = {}) {
+  const all = asArray(sources)
+    .map(ft => Array.from(ft.findServices(options.services)))
     .flat()
     .sort(sortByPriority)
-    .map(s => s[addressType])
-    .flat()
-    .filter(addressFilter);
-}
-
-export function serviceEndpoints(sources, filter, endpointFilter) {
-  return asArray(sources)
-    .map(ft => Array.from(ft.findServices(filter)))
-    .flat()
-    .sort(sortByPriority)
-    .map(service => service.endpoints(endpointFilter))
+    .map(service => service.endpoints(options.endpoints))
     .flat();
+
+  const res = new Set(options.select ? all.map(options.select) : all);
+
+  return options.join ? [...res].join(options.join) : res;
 }

package/src/services/dhcp.mjs

@@ -70,14 +70,13 @@ export class DHCPService extends Service {
 
     console.log("kea", host.name, network.name);
 
-    const dnsServerEndpoints = serviceEndpoints(
-      network,
-      {
+    const dnsServerEndpoints = serviceEndpoints(network, {
+      services: {
         type: "dns",
         priority: "<10"
       },
-      endpoint => endpoint.networkInterface.kind !== "loopback"
-    );
+      endpoints: endpoint => endpoint.networkInterface.kind !== "loopback"
+    });
 
     const packageData = {
       dir,

package/src/services/dns.mjs

@@ -9,13 +9,10 @@ import {
   dnsRecordTypeForAddressFamily,
   sortZoneRecords
 } from "../dns-utils.mjs";
-import { Endpoint, serviceEndpoints } from "pmcf";
+import { ExtraSourceService, Endpoint, serviceEndpoints } from "pmcf";
 import { addType } from "../types.mjs";
-import { ServiceTypeDefinition, serviceAddresses } from "../service.mjs";
-import {
-  ExtraSourceService,
-  ExtraSourceServiceTypeDefinition
-} from "../extra-source-service.mjs";
+import { ServiceTypeDefinition } from "../service.mjs";
+import { ExtraSourceServiceTypeDefinition } from "../extra-source-service.mjs";
 import { addresses } from "../network-support.mjs";
 import { addHook } from "../hooks.mjs";
 
@@ -90,8 +87,6 @@ const statisticsEndpoint = {
   tls: false
 };
 
-const DNS_SERVICE_FILTER = { type: DNSServiceTypeDefinition.name };
-
 function addressList(objects) {
   return Array.from(objects).map(object => {
     switch (typeof object) {
@@ -210,29 +205,6 @@ export class DNSService extends ExtraSourceService {
     return this._excludeInterfaceKinds;
   }
 
-  systemdConfig(name) {
-    return {
-      name: `etc/systemd/resolved.conf.d/${name}.conf`,
-      content: [
-        "Resolve",
-        {
-          DNS: serviceAddresses(this, {
-            ...DNS_SERVICE_FILTER,
-            priority: "<10"
-          }).join(" "),
-          FallbackDNS: serviceAddresses(this, {
-            ...DNS_SERVICE_FILTER,
-            priority: ">=10"
-          }).join(" "),
-          Domains: [...this.localDomains].join(" "),
-          DNSSEC: "no",
-          MulticastDNS: this.network.multicastDNS ? "yes" : "no",
-          LLMNR: "no"
-        }
-      ]
-    };
-  }
-
   async *preparePackages(dir) {
     const location = this.owner.owner;
     const name = location.name;
@@ -248,9 +220,10 @@ export class DNSService extends ExtraSourceService {
       }
     };
 
-    const forwarders = new Set(
-      serviceEndpoints(this.source, DNS_SERVICE_FILTER).map(e => e.address)
-    );
+    const forwarders = serviceEndpoints(this.source, {
+      services: { type: "dns", priority: ">=10" },
+      select: e => e.address
+    });
 
     if (forwarders.size) {
       await writeLines(
@@ -309,7 +282,7 @@ export class DNSService extends ExtraSourceService {
 
 async function generateZoneDefs(dns, location, packageData) {
   const ttl = dns.recordTTL;
-  const nameService = dns.findService(DNS_SERVICE_FILTER);
+  const nameService = dns.findService({ type: "dns", priority: "<10" });
   const rname = dns.administratorEmail.replace(/@/, ".");
 
   const SOARecord = DNSRecord(

package/src/services/ntp.mjs

@@ -24,8 +24,6 @@ const NTPServiceTypeDefinition = {
   }
 };
 
-const NTP_SERVICE_FILTER = { type: NTPServiceTypeDefinition.name };
-
 export class NTPService extends ExtraSourceService {
   static {
     addType(this);
@@ -64,19 +62,19 @@ export class NTPService extends ExtraSourceService {
     };
 
     const lines = [
-      ...serviceEndpoints(
-        this,
-        {
-          ...NTP_SERVICE_FILTER,
+      ...serviceEndpoints(this, {
+        services: {
+          type: "ntp",
           priority: ">=10"
         },
-        e => e.family === "IPv4" && e.networkInterface.kind !== "loopback"
-      ).map(
-        endpoint =>
+        endpoints: e =>
+          e.family === "IPv4" && e.networkInterface.kind !== "loopback",
+
+        select: endpoint =>
           `${endpoint.service.isPool ? "pool" : "server"} ${
             endpoint.address
           } iburst`
-      ),
+      }),
       `mailonchange ${this.administratorEmail} 0.5`,
       "local stratum 10",
       "leapsectz right/UTC",

package/src/services/systemd-resolved.mjs

@@ -0,0 +1,64 @@
+import {
+  ExtraSourceService,
+  ServiceTypeDefinition,
+  serviceEndpoints
+} from "pmcf";
+import { addType } from "../types.mjs";
+
+const SystemdResolvedServiceTypeDefinition = {
+  name: "systemd-resolved",
+  specializationOf: ServiceTypeDefinition,
+  owners: ServiceTypeDefinition.owners,
+  extends: ServiceTypeDefinition,
+  priority: 0.1,
+  properties: {}
+};
+
+export class SystemdResolvedService extends ExtraSourceService {
+  static {
+    addType(this);
+  }
+
+  static get typeDefinition() {
+    return SystemdResolvedServiceTypeDefinition;
+  }
+
+  constructor(owner, data) {
+    super(owner, data);
+    this.read(data, SystemdResolvedServiceTypeDefinition);
+  }
+
+  get type() {
+    return SystemdResolvedServiceTypeDefinition.name;
+  }
+
+  get systemdServices() {
+    return SystemdResolvedServiceTypeDefinition.name;
+  }
+
+  systemdConfig(name) {
+    const options = priority => {
+      return {
+        services: { type: "dns", priority },
+        endpoints: e => e.networkInterface.kind !== "loopback",
+        select: endpoint => endpoint.address,
+        join: " "
+      };
+    };
+
+    return {
+      name: `etc/systemd/resolved.conf.d/${name}.conf`,
+      content: [
+        "Resolve",
+        {
+          DNS: serviceEndpoints(this, options("<10")),
+          FallbackDNS: serviceEndpoints(this, options(">=10")),
+          Domains: [...this.localDomains].join(" "),
+          DNSSEC: "no",
+          MulticastDNS: this.network.multicastDNS ? "yes" : "no",
+          LLMNR: "no"
+        }
+      ]
+    };
+  }
+}

package/src/services/systemd-timesyncd.mjs

@@ -1,6 +1,8 @@
-import { Service, ServiceTypeDefinition } from "pmcf";
-import { serviceAddresses } from "../service.mjs";
-
+import {
+  ExtraSourceService,
+  ServiceTypeDefinition,
+  serviceEndpoints
+} from "pmcf";
 import { addType } from "../types.mjs";
 
 const SystemdTimesyncdServiceTypeDefinition = {
@@ -12,7 +14,7 @@ const SystemdTimesyncdServiceTypeDefinition = {
   properties: {}
 };
 
-export class SystemdTimesyncdService extends Service {
+export class SystemdTimesyncdService extends ExtraSourceService {
   static {
     addType(this);
   }
@@ -40,15 +42,16 @@ export class SystemdTimesyncdService extends Service {
       content: [
         "Time",
         {
-          NTP: serviceAddresses(
-            this,
-            {
+          NTP: serviceEndpoints(this, {
+            services: {
               type: "ntp",
               priority: "<20"
             },
-            "domainName",
-            () => true
-          ).join(" ")
+            endpoints: endpoint =>
+              endpoint.networkInterface.kind !== "loopback",
+            select: endpoint => endpoint.domainName,
+            join: " "
+          })
         }
       ]
     };

package/types/endpoint.d.mts

@@ -5,7 +5,16 @@ export class Endpoint {
     toString(): string;
     get socketAddress(): string;
     get hostName(): any;
+    get domainName(): any;
     get address(): any;
     get family(): any;
     get networkInterface(): any;
 }
+export class DomainNameEndpoint {
+    constructor(service: any, domainName: any, data: any);
+    service: any;
+    domainName: any;
+    get networkInterface(): {};
+    get address(): any;
+    toString(): string;
+}

package/types/location.d.mts

@@ -292,5 +292,5 @@ export class Location extends Owner {
         };
     }, void, unknown>;
 }
-import { Owner } from "./owner.mjs";
+import { Owner } from "pmcf";
 import { FileContentProvider } from "npm-pkgbuild";

package/types/module.d.mts

@@ -15,10 +15,12 @@ export * from "./network-interfaces/wlan.mjs";
 export * from "./network-interfaces/wireguard.mjs";
 export * from "./host.mjs";
 export * from "./service.mjs";
+export * from "./extra-source-service.mjs";
 export * from "./endpoint.mjs";
 export * from "./services/dns.mjs";
 export * from "./services/ntp.mjs";
 export * from "./services/dhcp.mjs";
 export * from "./services/systemd-journal.mjs";
 export * from "./services/systemd-timesyncd.mjs";
+export * from "./services/systemd-resolved.mjs";
 export * from "./types.mjs";

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

@@ -7,6 +7,7 @@ export class SkeletonNetworkInterface extends ServiceOwner {
     get host(): Host;
     hosts(): Generator<any, void, any>;
     get network_interface(): this;
+    get domainName(): any;
     get domainNames(): Set<any>;
     matches(other: any): boolean;
     set network(network: any);

package/types/service.d.mts

@@ -1,5 +1,4 @@
-export function serviceAddresses(sources: any, filter: any, addressType?: string, addressFilter?: (a: any) => boolean): any[];
-export function serviceEndpoints(sources: any, filter: any, endpointFilter: any): any[];
+export function serviceEndpoints(sources: any, options?: {}): string | Set<any>;
 export namespace endpointProperties {
     export namespace port {
         let type: string;

package/types/services/dns.d.mts

@@ -377,17 +377,6 @@ export class DNSService extends ExtraSourceService {
     get exclude(): Set<any>;
     set excludeInterfaceKinds(value: Set<any>);
     get excludeInterfaceKinds(): Set<any>;
-    systemdConfig(name: any): {
-        name: string;
-        content: (string | {
-            DNS: string;
-            FallbackDNS: string;
-            Domains: string;
-            DNSSEC: string;
-            MulticastDNS: string;
-            LLMNR: string;
-        })[];
-    };
     preparePackages(dir: any): AsyncGenerator<{
         dir: string;
         sources: FileContentProvider[];
@@ -399,5 +388,5 @@ export class DNSService extends ExtraSourceService {
         };
     }, void, unknown>;
 }
-import { ExtraSourceService } from "../extra-source-service.mjs";
+import { ExtraSourceService } from "pmcf";
 import { FileContentProvider } from "npm-pkgbuild";

package/types/services/systemd-resolved.d.mts

@@ -0,0 +1,269 @@
+export class SystemdResolvedService extends ExtraSourceService {
+    static get typeDefinition(): {
+        name: string;
+        specializationOf: {
+            name: string;
+            owners: string[];
+            priority: number;
+            extends: {
+                name: string;
+                owners: any[];
+                properties: {
+                    owner: {
+                        type: string;
+                        collection: boolean;
+                        writeable: boolean;
+                    };
+                    type: {
+                        type: string;
+                        collection: boolean;
+                        writeable: boolean;
+                    };
+                    name: {
+                        type: string;
+                        collection: boolean;
+                        identifier: boolean;
+                        writeable: boolean;
+                    };
+                    description: {
+                        type: string;
+                        collection: boolean;
+                        writeable: boolean;
+                    };
+                    priority: {
+                        type: string;
+                        collection: boolean;
+                        writeable: boolean;
+                    };
+                    directory: {
+                        type: string;
+                        collection: boolean;
+                        writeable: boolean;
+                    };
+                    packaging: {
+                        type: string;
+                        collection: boolean;
+                        writeable: boolean;
+                    };
+                    tags: {
+                        type: string;
+                        collection: boolean;
+                        writeable: boolean;
+                    };
+                };
+            };
+            specializations: {};
+            factoryFor(owner: any, value: any): any;
+            properties: {
+                ipAddresses: {
+                    type: string;
+                    collection: boolean;
+                    writeable: boolean;
+                };
+                alias: {
+                    type: string;
+                    collection: boolean;
+                    writeable: boolean;
+                };
+                weight: {
+                    type: string;
+                    collection: boolean;
+                    writeable: boolean;
+                    default: number;
+                };
+                systemd: {
+                    type: string;
+                    collection: boolean;
+                    writeable: boolean;
+                };
+                port: {
+                    type: string;
+                    collection: boolean;
+                    writeable: boolean;
+                };
+                protocol: {
+                    type: string;
+                    collection: boolean;
+                    writeable: boolean;
+                    values: string[];
+                };
+                type: {
+                    type: string;
+                    collection: boolean;
+                    writeable: boolean;
+                };
+                tls: {
+                    type: string;
+                    collection: boolean;
+                    writeable: boolean;
+                    default: boolean;
+                };
+                hostName: {
+                    type: string;
+                    collection: boolean;
+                    writeable: boolean;
+                };
+                cidrAddresses: {
+                    type: string;
+                    collection: boolean;
+                    writeable: boolean;
+                };
+                cidrAddress: {
+                    type: string;
+                    collection: boolean;
+                    writeable: boolean;
+                };
+                addresses: {
+                    type: string;
+                    collection: boolean;
+                    writeable: boolean;
+                };
+                address: {
+                    type: string;
+                    collection: boolean;
+                    writeable: boolean;
+                };
+            };
+        };
+        owners: string[];
+        extends: {
+            name: string;
+            owners: string[];
+            priority: number;
+            extends: {
+                name: string;
+                owners: any[];
+                properties: {
+                    owner: {
+                        type: string;
+                        collection: boolean;
+                        writeable: boolean;
+                    };
+                    type: {
+                        type: string;
+                        collection: boolean;
+                        writeable: boolean;
+                    };
+                    name: {
+                        type: string;
+                        collection: boolean;
+                        identifier: boolean;
+                        writeable: boolean;
+                    };
+                    description: {
+                        type: string;
+                        collection: boolean;
+                        writeable: boolean;
+                    };
+                    priority: {
+                        type: string;
+                        collection: boolean;
+                        writeable: boolean;
+                    };
+                    directory: {
+                        type: string;
+                        collection: boolean;
+                        writeable: boolean;
+                    };
+                    packaging: {
+                        type: string;
+                        collection: boolean;
+                        writeable: boolean;
+                    };
+                    tags: {
+                        type: string;
+                        collection: boolean;
+                        writeable: boolean;
+                    };
+                };
+            };
+            specializations: {};
+            factoryFor(owner: any, value: any): any;
+            properties: {
+                ipAddresses: {
+                    type: string;
+                    collection: boolean;
+                    writeable: boolean;
+                };
+                alias: {
+                    type: string;
+                    collection: boolean;
+                    writeable: boolean;
+                };
+                weight: {
+                    type: string;
+                    collection: boolean;
+                    writeable: boolean;
+                    default: number;
+                };
+                systemd: {
+                    type: string;
+                    collection: boolean;
+                    writeable: boolean;
+                };
+                port: {
+                    type: string;
+                    collection: boolean;
+                    writeable: boolean;
+                };
+                protocol: {
+                    type: string;
+                    collection: boolean;
+                    writeable: boolean;
+                    values: string[];
+                };
+                type: {
+                    type: string;
+                    collection: boolean;
+                    writeable: boolean;
+                };
+                tls: {
+                    type: string;
+                    collection: boolean;
+                    writeable: boolean;
+                    default: boolean;
+                };
+                hostName: {
+                    type: string;
+                    collection: boolean;
+                    writeable: boolean;
+                };
+                cidrAddresses: {
+                    type: string;
+                    collection: boolean;
+                    writeable: boolean;
+                };
+                cidrAddress: {
+                    type: string;
+                    collection: boolean;
+                    writeable: boolean;
+                };
+                addresses: {
+                    type: string;
+                    collection: boolean;
+                    writeable: boolean;
+                };
+                address: {
+                    type: string;
+                    collection: boolean;
+                    writeable: boolean;
+                };
+            };
+        };
+        priority: number;
+        properties: {};
+    };
+    get systemdServices(): string;
+    systemdConfig(name: any): {
+        name: string;
+        content: (string | {
+            DNS: string | Set<any>;
+            FallbackDNS: string | Set<any>;
+            Domains: string;
+            DNSSEC: string;
+            MulticastDNS: string;
+            LLMNR: string;
+        })[];
+    };
+}
+import { ExtraSourceService } from "pmcf";

package/types/services/systemd-timesyncd.d.mts

@@ -1,4 +1,4 @@
-export class SystemdTimesyncdService extends Service {
+export class SystemdTimesyncdService extends ExtraSourceService {
     static get typeDefinition(): {
         name: string;
         specializationOf: {
@@ -253,13 +253,12 @@ export class SystemdTimesyncdService extends Service {
         priority: number;
         properties: {};
     };
-    get type(): string;
     get systemdServices(): string;
     systemdConfig(name: any): {
         name: string;
         content: (string | {
-            NTP: string;
+            NTP: string | Set<any>;
         })[];
     };
 }
-import { Service } from "pmcf";
+import { ExtraSourceService } from "pmcf";