pmcf 2.33.2 → 2.33.4

package/package.json

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

package/src/location.mjs

@@ -70,27 +70,20 @@ export class Location extends Owner {
       }
     };
 
-    await writeLines(
-      join(dir, "etc/systemd/resolved.conf.d"),
-      `${this.name}.conf`,
-      sectionLines(...this.findService({ type: "dns" }).systemdConfig)
-    );
+    const configs = [
+      { type: "dns" },
+      { type: "ntp" },
+      { type: "systemd-journald" }
+    ];
 
-    await writeLines(
-      join(dir, "etc/systemd/journald.conf.d"),
-      `${this.name}.conf`,
-      sectionLines("Journal", {
-        Compress: "yes",
-        SystemMaxUse: "500M",
-        SyncIntervalSec: "15m"
-      })
-    );
+    for (const cfg of configs) {
+      const service = this.findService(cfg);
 
-    await writeLines(
-      join(dir, "etc/systemd/timesyncd.conf.d"),
-      `${this.name}.conf`,
-      sectionLines(...this.findService({ type: "ntp" }).systemdConfig)
-    );
+      if (service) {
+        const { name, content } = service.systemdConfig(this.name);
+        await writeLines(dir, name, sectionLines(...content));
+      }
+    }
 
     yield packageData;
   }

package/src/module.mjs

@@ -19,4 +19,5 @@ export * from "./endpoint.mjs";
 export * from "./services/dns.mjs";
 export * from "./services/ntp.mjs";
 export * from "./services/dhcp.mjs";
+export * from "./services/systemd-journald.mjs";
 export * from "./types.mjs";

package/src/service.mjs

@@ -11,6 +11,11 @@ import {
 } from "./dns-utils.mjs";
 
 const ServiceTypes = {
+  "systemd-resolved": { endpoints: [] },
+  "systemd-timesyncd": { endpoints: [] },
+  "systemd-journald": { endpoints: [] },
+  "systemd-journal-remote": { endpoints: [] },
+  "systemd-journal-upload": { endpoints: [] },
   ntp: { endpoints: [{ protocol: "udp", port: 123, tls: false }] },
   dns: { endpoints: [{ protocol: "udp", port: 53, tls: false }] },
   ldap: { endpoints: [{ protocol: "tcp", port: 389, tls: false }] },
@@ -149,7 +154,7 @@ export class Service extends Base {
   }
 
   get host() {
-    if(this.owner instanceof Host) {
+    if (this.owner instanceof Host) {
       return this.owner;
     }
   }

package/src/services/dns.mjs

@@ -210,24 +210,27 @@ export class DNSService extends ExtraSourceService {
     return this._excludeInterfaceKinds;
   }
 
-  get systemdConfig() {
-    return [
-      "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"
-      }
-    ];
+  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) {
@@ -367,7 +370,12 @@ async function generateZoneDefs(dns, location, packageData) {
     );
   }
 
-  console.log("LOCAL DOMAINS", location.localDomains, location.domain, location.toString());
+  console.log(
+    "LOCAL DOMAINS",
+    location.localDomains,
+    location.domain,
+    location.toString()
+  );
 
   for (const domain of location.localDomains) {
     const locationName = location.name;
@@ -418,7 +426,7 @@ async function generateZoneDefs(dns, location, packageData) {
       domainNames,
       family
     } of location.networkAddresses()) {
-      console.log("ADDRESS",address);
+      console.log("ADDRESS", address);
 
       if (
         !dns.exclude.has(networkInterface.network) &&

package/src/services/ntp.mjs

@@ -48,21 +48,24 @@ export class NTPService extends ExtraSourceService {
     return NTPServiceTypeDefinition.name;
   }
 
-  get systemdConfig() {
-    return [
-      "Time",
-      {
-        NTP: serviceAddresses(
-          this,
-          {
-            ...NTP_SERVICE_FILTER,
-            priority: "<20"
-          },
-          "domainName",
-          () => true
-        ).join(" ")
-      }
-    ];
+  systemdConfig(name) {
+    return {
+      name: `etc/systemd/timesyncd.conf.d/${name}.conf`,
+      content: [
+        "Time",
+        {
+          NTP: serviceAddresses(
+            this,
+            {
+              ...NTP_SERVICE_FILTER,
+              priority: "<20"
+            },
+            "domainName",
+            () => true
+          ).join(" ")
+        }
+      ]
+    };
   }
 
   async *preparePackages(dir) {
@@ -91,7 +94,7 @@ export class NTPService extends ExtraSourceService {
           ...NTP_SERVICE_FILTER,
           priority: ">=10"
         },
-        e => e.family === 'IPv4' && e.networkInterface.kind !== "loopback"
+        e => e.family === "IPv4" && e.networkInterface.kind !== "loopback"
       ).map(
         endpoint =>
           `${endpoint.service.isPool ? "pool" : "server"} ${

package/src/services/systemd-journald.mjs

@@ -0,0 +1,48 @@
+import { Service, ServiceTypeDefinition } from "pmcf";
+import { addType } from "../types.mjs";
+
+const SystemdJournaldServiceTypeDefinition = {
+  name: "systemd-journald",
+  specializationOf: ServiceTypeDefinition,
+  owners: ServiceTypeDefinition.owners,
+  extends: ServiceTypeDefinition,
+  priority: 0.1,
+  properties: {}
+};
+
+export class SystemdJournaldService extends Service {
+  static {
+    addType(this);
+  }
+
+  static get typeDefinition() {
+    return SystemdJournaldServiceTypeDefinition;
+  }
+
+  constructor(owner, data) {
+    super(owner, data);
+    this.read(data, SystemdJournaldServiceTypeDefinition);
+  }
+
+  get type() {
+    return SystemdJournaldServiceTypeDefinition.name;
+  }
+
+  get systemdServices() {
+    return SystemdJournaldServiceTypeDefinition.name;
+  }
+
+  systemdConfig(name) {
+    return {
+      name: `etc/systemd/journal.conf.d/${name}.conf`,
+      content: [
+        "Journal",
+        {
+          Compress: "yes",
+          SystemMaxUse: "500M",
+          SyncIntervalSec: "15m"
+        }
+      ]
+    };
+  }
+}

package/types/module.d.mts

@@ -19,4 +19,5 @@ export * from "./endpoint.mjs";
 export * from "./services/dns.mjs";
 export * from "./services/ntp.mjs";
 export * from "./services/dhcp.mjs";
+export * from "./services/systemd-journald.mjs";
 export * from "./types.mjs";

package/types/services/dns.d.mts

@@ -377,14 +377,17 @@ export class DNSService extends ExtraSourceService {
     get exclude(): Set<any>;
     set excludeInterfaceKinds(value: Set<any>);
     get excludeInterfaceKinds(): Set<any>;
-    get systemdConfig(): (string | {
-        DNS: string;
-        FallbackDNS: string;
-        Domains: string;
-        DNSSEC: string;
-        MulticastDNS: string;
-        LLMNR: string;
-    })[];
+    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[];

package/types/services/ntp.d.mts

@@ -272,9 +272,12 @@ export class NTPService extends ExtraSourceService {
             };
         };
     };
-    get systemdConfig(): (string | {
-        NTP: string;
-    })[];
+    systemdConfig(name: any): {
+        name: string;
+        content: (string | {
+            NTP: string;
+        })[];
+    };
     preparePackages(dir: any): AsyncGenerator<{
         dir: any;
         sources: FileContentProvider[];

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

@@ -0,0 +1,267 @@
+export class SystemdJournaldService extends Service {
+    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 type(): string;
+    get systemdServices(): string;
+    systemdConfig(name: any): {
+        name: string;
+        content: (string | {
+            Compress: string;
+            SystemMaxUse: string;
+            SyncIntervalSec: string;
+        })[];
+    };
+}
+import { Service } from "pmcf";