pmcf 4.25.13 → 4.25.14

package/package.json

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

package/src/base.mjs

@@ -55,7 +55,7 @@ export class Base {
   }
 
   static get typeName() {
-    return this.typeDefinition.name;
+    return this.typeDefinition?.name || this.name;
   }
 
   static get typeFileName() {

package/src/service.mjs

@@ -52,7 +52,7 @@ export const ServiceTypeDefinition = {
   name: "service",
   priority: 1.1,
   owners: [Host.typeDefinition, "cluster", "network_interface"],
-  extends: Base.typeDefinition,
+  extends: Base,
   specializations: {},
   factoryFor(owner, value) {
     const type = value.type ?? value.name;

package/src/services/bind.mjs

@@ -33,11 +33,10 @@ import { addHook } from "../hooks.mjs";
 
 const bindNetworkAddressTypes = networkAddressType + "|bind_group";
 
-const BindGroupTypeDefinition = {
-  name: "bind_group",
-  priority: 1,
-  key: "name",
-  attributes: {
+class bind_group extends Base {
+  static priority = 1;
+  static key = "name";
+  static attributes = {
     name: name_attribute_writable,
     access: {
       type: bindNetworkAddressTypes,
@@ -77,11 +76,9 @@ const BindGroupTypeDefinition = {
     retry: { ...duration_attribute_writable, default: 72000 },
     expire: { ...duration_attribute_writable, default: 600000 },
     minimum: { ...duration_attribute_writable, default: 60000 }
-  }
-};
+  };
 
-class BindGroup extends Base {
-  static typeDefinition = BindGroupTypeDefinition;
+  static typeDefinition = this;
   static {
     addType(this);
   }
@@ -94,8 +91,7 @@ class BindGroup extends Base {
   notify = true;
   hasCatalog = true;
   hasSVRRecords = true;
-  hasLinkLocalAdresses =
-    BindGroupTypeDefinition.attributes.hasLinkLocalAdresses.default;
+  hasLinkLocalAdresses = bind_group.attributes.hasLinkLocalAdresses.default;
 
   recordTTL = "1W";
 
@@ -392,16 +388,26 @@ class BindGroup extends Base {
   }
 }
 
-const BindServiceTypeDefinition = {
-  name: "bind",
-  extends: ExtraSourceServiceTypeDefinition,
-  specializationOf: ServiceTypeDefinition,
-  owners: ServiceTypeDefinition.owners,
-  key: "name",
-  attributes: {
+function addressesStatement(prefix, objects, generateEmpty = false) {
+  const body = asArray(objects).map(name => `  ${name};`);
+
+  if (body.length || generateEmpty) {
+    return [`${prefix} {`, body, "};"];
+  }
+
+  return [];
+}
+
+export class BindService extends ExtraSourceService {
+  static name = "bind";
+  static extends = ExtraSourceServiceTypeDefinition;
+  static specializationOf = ServiceTypeDefinition;
+  static owners = ServiceTypeDefinition.owners;
+  static key = "name";
+  static attributes = {
     groups: {
       ...default_attribute_writable,
-      type: BindGroupTypeDefinition,
+      type: bind_group,
       collection: true,
       writable: true
     },
@@ -410,8 +416,8 @@ const BindServiceTypeDefinition = {
       type: networkAddressType,
       collection: true
     }
-  },
-  service: {
+  };
+  static service = {
     systemdService: "bind.service",
     extends: ["dns"],
     services: {
@@ -447,31 +453,19 @@ const BindServiceTypeDefinition = {
         ]
       }
     }
-  }
-};
-
-function addressesStatement(prefix, objects, generateEmpty = false) {
-  const body = asArray(objects).map(name => `  ${name};`);
-
-  if (body.length || generateEmpty) {
-    return [`${prefix} {`, body, "};"];
-  }
-
-  return [];
-}
+  };
 
-export class BindService extends ExtraSourceService {
-  static typeDefinition = BindServiceTypeDefinition;
+  static typeDefinition = this;
 
   static {
     addType(this);
-    addServiceType(this.typeDefinition.service, this.typeDefinition.name);
+    addServiceType(this.service, this.name);
   }
 
   groups = {};
 
   get type() {
-    return BindServiceTypeDefinition.name;
+    return this.constructor.name;
   }
 
   materializeExtends() {
@@ -522,7 +516,7 @@ export class BindService extends ExtraSourceService {
   }
 
   typeNamed(type, name) {
-    if (type === BindGroupTypeDefinition.name) {
+    if (type === bind_group.name) {
       return this.groups[name];
     }
 

package/src/services/chrony.mjs

@@ -10,14 +10,14 @@ import {
 } from "../extra-source-service.mjs";
 import { writeLines } from "../utils.mjs";
 
-const ChronyServiceTypeDefinition = {
-  name: "chrony",
-  priority: 1,
-  extends: ExtraSourceServiceTypeDefinition,
-  specializationOf: ServiceTypeDefinition,
-  owners: ServiceTypeDefinition.owners,
-  key: "name",
-  service: {
+export class ChronyService extends ExtraSourceService {
+  static name = "chrony";
+  static priority = 1;
+  static extends = ExtraSourceServiceTypeDefinition;
+  static specializationOf = ServiceTypeDefinition;
+  static owners = ServiceTypeDefinition.owners;
+  static key = "name";
+  static service = {
     systemdService: "chronyd.service",
     extends: ["ntp"],
     services: {
@@ -42,18 +42,16 @@ const ChronyServiceTypeDefinition = {
         ]
       }
     }
-  }
-};
+  };
 
-export class ChronyService extends ExtraSourceService {
-  static typeDefinition = ChronyServiceTypeDefinition;
+  static typeDefinition = this;
   static {
     addType(this);
-    addServiceType(this.typeDefinition.service, this.typeDefinition.name);
+    addServiceType(this.service, this.name);
   }
 
   get type() {
-    return ChronyServiceTypeDefinition.name;
+    return this.constructor.name;
   }
 
   async *preparePackages(dir) {

package/src/services/headscale.mjs

@@ -2,14 +2,14 @@ import { addType } from "pacc";
 import { addServiceType } from "pmcf";
 import { ServiceTypeDefinition, Service } from "../service.mjs";
 
-const HeadscaleServiceTypeDefinition = {
-  name: "headscale",
-  priority: 1,
-  extends: ServiceTypeDefinition,
-  specializationOf: ServiceTypeDefinition,
-  owners: ServiceTypeDefinition.owners,
-  key: "name",
-  service: {
+export class HeadscaleService extends Service {
+  static name = "headscale";
+  static priority = 1;
+  static extends = ServiceTypeDefinition;
+  static specializationOf = ServiceTypeDefinition;
+  static owners = ServiceTypeDefinition.owners;
+  static key = "name";
+  static service = {
     endpoints: [
       {
         family: "unix",
@@ -36,13 +36,10 @@ const HeadscaleServiceTypeDefinition = {
         tls: false
       }
     ]
-  }
-};
-
-export class HeadscaleService extends Service {
-  static typeDefinition = HeadscaleServiceTypeDefinition;
+  };
+  static typeDefinition = this;
   static {
     addType(this);
-    addServiceType(this.typeDefinition.service, this.typeDefinition.name);
+    addServiceType(this.service, this.name);
   }
 }

package/src/services/influxdb.mjs

@@ -9,21 +9,21 @@ import {
 } from "../utils.mjs";
 import { Service, ServiceTypeDefinition } from "../service.mjs";
 
-const InfluxdbServiceTypeDefinition = {
-  name: "influxdb",
-  priority: 1,
-  extends: ServiceTypeDefinition,
-  specializationOf: ServiceTypeDefinition,
-  owners: ServiceTypeDefinition.owners,
-  key: "name",
-  attributes: {
+export class InfluxdbService extends Service {
+  static name = "influxdb";
+  static priority = 1;
+  static extends = ServiceTypeDefinition;
+  static specializationOf = ServiceTypeDefinition;
+  static owners = ServiceTypeDefinition.owners;
+  static key = "name";
+  static attributes = {
     metricsDisabled: {
       externalName: "metrics-disabled",
       ...boolean_attribute_writable_true,
       configurable: true
     }
-  },
-  service: {
+  };
+  static service = {
     endpoints: [
       {
         family: "IPv4",
@@ -40,18 +40,16 @@ const InfluxdbServiceTypeDefinition = {
         pathname: "/"
       }
     ]
-  }
-};
+  };
 
-export class InfluxdbService extends Service {
-  static typeDefinition = InfluxdbServiceTypeDefinition;
+  static typeDefinition = this;
   static {
     addType(this);
-    addServiceType(this.typeDefinition.service, this.typeDefinition.name);
+    addServiceType(this.service, this.name);
   }
 
   get type() {
-    return InfluxdbServiceTypeDefinition.name;
+    return this.constructor.name;
   }
 
   async *preparePackages(dir) {
@@ -62,7 +60,9 @@ export class InfluxdbService extends Service {
     await writeLines(
       join(dir, "etc", "influxdb"),
       "config.yml",
-      setionLinesFromPropertyIterator(this.attributeIterator(filterConfigurable))
+      setionLinesFromPropertyIterator(
+        this.attributeIterator(filterConfigurable)
+      )
     );
 
     yield packageData;

package/src/services/kea.mjs

@@ -18,14 +18,16 @@ import {
 } from "pmcf";
 import { writeLines } from "../utils.mjs";
 
-const KeaServiceTypeDefinition = {
-  name: "kea",
-  priority: 1,
-  extends: ServiceTypeDefinition,
-  specializationOf: ServiceTypeDefinition,
-  owners: ServiceTypeDefinition.owners,
-  key: "name",
-  attributes: {
+const keaVersion = "3.0.1";
+
+export class KeaService extends Service {
+  static name = "kea";
+  static priority = 1;
+  static extends = ServiceTypeDefinition;
+  static specializationOf = ServiceTypeDefinition;
+  static owners = ServiceTypeDefinition.owners;
+  static key = "name";
+  static attributes = {
     "ddns-send-updates": {
       ...boolean_attribute_writable_true,
       configurable: true
@@ -51,8 +53,8 @@ const KeaServiceTypeDefinition = {
       configurable: true
       //values: ["check-exists-with-dhcid","no-check-with-dhcid"]
     }
-  },
-  service: {
+  };
+  static service = {
     extends: ["dhcp"],
     services: {
       "kea-ddns": {
@@ -124,20 +126,16 @@ const KeaServiceTypeDefinition = {
         ]
       }
     }
-  }
-};
+  };
 
-const keaVersion = "3.0.1";
-
-export class KeaService extends Service {
-  static typeDefinition = KeaServiceTypeDefinition;
+  static typeDefinition = this;
   static {
     addType(this);
-    addServiceType(this.typeDefinition.service, this.typeDefinition.name);
+    addServiceType(this.service, this.name);
   }
 
   get type() {
-    return KeaServiceTypeDefinition.name;
+    return this.constructor.name;
   }
 
   async *preparePackages(dir) {

package/src/services/mosquitto.mjs

@@ -2,14 +2,14 @@ import { port_attribute, string_attribute_writable, addType } from "pacc";
 import { addServiceType } from "pmcf";
 import { Service, ServiceTypeDefinition } from "../service.mjs";
 
-const MosquittoServiceTypeDefinition = {
-  name: "mosquitto",
-  priority: 1,
-  extends: ServiceTypeDefinition,
-  specializationOf: ServiceTypeDefinition,
-  owners: ServiceTypeDefinition.owners,
-  key: "name",
-  attributes: {
+export class MosquittoService extends Service {
+  static name = "mosquitto";
+  static priority = 1;
+  static extends = ServiceTypeDefinition;
+  static specializationOf = ServiceTypeDefinition;
+  static owners = ServiceTypeDefinition.owners;
+  static key = "name";
+  static attributes = {
     listener: {
       ...port_attribute,
       writable: true,
@@ -27,21 +27,18 @@ const MosquittoServiceTypeDefinition = {
       ...string_attribute_writable,
       configurable: true
     }
-  },
-  service: {
+  };
+  static service = {
     extends: ["mqtt"]
-  }
-};
-
-export class MosquittoService extends Service {
-  static typeDefinition = MosquittoServiceTypeDefinition;
+  };
+  static typeDefinition = this;
   static {
     addType(this);
-    addServiceType(this.typeDefinition.service, this.typeDefinition.name);
+    addServiceType(this.service, this.name);
   }
 
   get type() {
-    return MosquittoServiceTypeDefinition.name;
+    return this.constructor.name;
   }
 
   get listener() {

package/src/services/openldap.mjs

@@ -1,42 +1,34 @@
-import { FileContentProvider } from "npm-pkgbuild";
-import {
-  string_attribute_writable,
-  number_attribute_writable,
-  object_attribute,
-  addType
-} from "pacc";
+import { string_attribute_writable, addType } from "pacc";
 import { addServiceType } from "pmcf";
 import { ServiceTypeDefinition, Service } from "../service.mjs";
 
-const OpenLDAPServiceTypeDefinition = {
-  name: "openldap",
-  priority: 1,
-  extends: ServiceTypeDefinition,
-  specializationOf: ServiceTypeDefinition,
-  owners: ServiceTypeDefinition.owners,
-  key: "name",
-  attributes: {
+export class OpenLDAPService extends Service {
+  static name = "openldap";
+  static priority = 1;
+  static extends = ServiceTypeDefinition;
+  static specializationOf = ServiceTypeDefinition;
+  static owners = ServiceTypeDefinition.owners;
+  static key = "name";
+  static attributes = {
     base: string_attribute_writable,
     uri: string_attribute_writable
-  },
-  service: {
+  };
+  static service = {
     systemdService: "slapd.service",
     extends: ["ldap", "ldapi"],
     services: {}
-  }
-};
+  };
 
-export class OpenLDAPService extends Service {
-  static typeDefinition = OpenLDAPServiceTypeDefinition;
+  static typeDefinition = this;
   static {
     addType(this);
-    addServiceType(this.typeDefinition.service, this.typeDefinition.name);
+    addServiceType(this.service, this.name);
   }
 
   _base;
 
   get type() {
-    return OpenLDAPServiceTypeDefinition.name;
+    return this.constructor.name;
   }
 
   get base() {

package/src/services/postfix.mjs

@@ -23,6 +23,6 @@ export class PostfixService extends Service {
   }
 
   get type() {
-    return "postfix";
+    return this.constructor.name;
   }
 }

package/src/services/systemd-journal-remote.mjs

@@ -8,14 +8,18 @@ import {
 import { Service, ServiceTypeDefinition, addServiceType } from "pmcf";
 import { filterConfigurable, sectionLines } from "../utils.mjs";
 
-const SystemdJournalRemoteServiceTypeDefinition = {
-  name: "systemd-journal-remote",
-  priority: 1,
-  extends: ServiceTypeDefinition,
-  specializationOf: ServiceTypeDefinition,
-  owners: ServiceTypeDefinition.owners,
-  key: "name",
-  attributes: {
+/**
+ * @property {string} ServerCertificateFile
+ * @property {string} ServerKeyFile
+ */
+export class SystemdJournalRemoteService extends Service {
+  static name = "systemd-journal-remote";
+  static priority = 1;
+  static extends = ServiceTypeDefinition;
+  static specializationOf = ServiceTypeDefinition;
+  static owners = ServiceTypeDefinition.owners;
+  static key = "name";
+  static attributes = {
     Seal: {
       ...boolean_attribute_writable,
       configurable: true
@@ -61,8 +65,8 @@ const SystemdJournalRemoteServiceTypeDefinition = {
       configurable: true
       //   default: "zstd lz4 xz"
     }
-  },
-  service: {
+  };
+  static service = {
     systemdService: "systemd-journal-remote.service",
     endpoints: [
       {
@@ -80,22 +84,16 @@ const SystemdJournalRemoteServiceTypeDefinition = {
         pathname: "/"
       }
     ]
-  }
-};
+  };
 
-/**
- * @property {string} ServerCertificateFile
- * @property {string} ServerKeyFile
- */
-export class SystemdJournalRemoteService extends Service {
-  static typeDefinition = SystemdJournalRemoteServiceTypeDefinition;
+  static typeDefinition = this;
   static {
     addType(this);
-    addServiceType(this.typeDefinition.service, this.typeDefinition.name);
+    addServiceType(this.service, this.name);
   }
 
   get type() {
-    return SystemdJournalRemoteServiceTypeDefinition.name;
+    return this.constructor.name;
   }
 
   /**

package/src/services/systemd-journal-upload.mjs

@@ -7,14 +7,19 @@ import {
 import { Service, ServiceTypeDefinition, addServiceType } from "pmcf";
 import { filterConfigurable, sectionLines } from "../utils.mjs";
 
-const SystemdJournalUploadServiceTypeDefinition = {
-  name: "systemd-journal-upload",
-  priority: 1,
-  extends: ServiceTypeDefinition,
-  specializationOf: ServiceTypeDefinition,
-  owners: ServiceTypeDefinition.owners,
-  key: "name",
-  attributes: {
+/**
+ * @property {string} URL
+ * @property {string} ServerCertificateFile
+ * @property {string} ServerKeyFile
+ */
+export class SystemdJournalUploadService extends Service {
+  static name = "systemd-journal-upload";
+  static priority = 1;
+  static extends = ServiceTypeDefinition;
+  static specializationOf = ServiceTypeDefinition;
+  static owners = ServiceTypeDefinition.owners;
+  static key = "name";
+  static attributes = {
     URL: { ...string_attribute_writable, configurable: true },
     ServerKeyFile: {
       ...string_attribute_writable,
@@ -41,26 +46,18 @@ const SystemdJournalUploadServiceTypeDefinition = {
       configurable: true
       // default: false
     }
-  },
-  service: {
+  };
+  static service = {
     systemdService: "systemd-journal-upload.service"
-  }
-};
-
-/**
- * @property {string} URL
- * @property {string} ServerCertificateFile
- * @property {string} ServerKeyFile
- */
-export class SystemdJournalUploadService extends Service {
-  static typeDefinition = SystemdJournalUploadServiceTypeDefinition;
+  };
+  static typeDefinition = this;
   static {
     addType(this);
-    addServiceType(this.typeDefinition.service, this.typeDefinition.name);
+    addServiceType(this.service, this.name);
   }
 
   get type() {
-    return SystemdJournalUploadServiceTypeDefinition.name;
+    return this.constructor.name;
   }
 
   /**
@@ -69,9 +66,9 @@ export class SystemdJournalUploadService extends Service {
    * @returns {Object}
    */
   systemdConfigs(name) {
-    console.log(this.fullName,this.owner.fullName);
-    console.log(this.property('domainName'),this.name);
-    console.log(this.property('certs_private_dir'));
+    console.log(this.fullName, this.owner.fullName);
+    console.log(this.property("domainName"), this.name);
+    console.log(this.property("certs_private_dir"));
     console.log("PROPS", this.expand(this.getAttributes(filterConfigurable)));
     return {
       serviceName: this.systemdService,

package/src/services/systemd-journald.mjs

@@ -6,14 +6,14 @@ import {
 import { Service, ServiceTypeDefinition, addServiceType } from "pmcf";
 import { filterConfigurable, sectionLines } from "../utils.mjs";
 
-const SystemdJournalServiceTypeDefinition = {
-  name: "systemd-journald",
-  priority: 1,
-  extends: ServiceTypeDefinition,
-  specializationOf: ServiceTypeDefinition,
-  owners: ServiceTypeDefinition.owners,
-  key: "name",
-  attributes: {
+export class SystemdJournaldService extends Service {
+  static name = "systemd-journald";
+  static priority = 1;
+  static extends = ServiceTypeDefinition;
+  static specializationOf = ServiceTypeDefinition;
+  static owners = ServiceTypeDefinition.owners;
+  static key = "name";
+  static attributes = {
     Storage: {
       ...string_attribute_writable,
       configurable: true
@@ -106,21 +106,18 @@ const SystemdJournalServiceTypeDefinition = {
       ...string_attribute_writable,
       configurable: true
     }
-  },
-  service: {
+  };
+  static service = {
     systemdService: "systemd-journald.service"
-  }
-};
-
-export class SystemdJournaldService extends Service {
-  static typeDefinition = SystemdJournalServiceTypeDefinition;
+  };
+  static typeDefinition = this;
   static {
     addType(this);
-    addServiceType(this.typeDefinition.service, this.typeDefinition.name);
+    addServiceType(this.service, this.name);
   }
 
   get type() {
-    return SystemdJournalServiceTypeDefinition.name;
+    return this.constructor.name;
   }
 
   systemdConfigs(name) {

package/src/services/systemd-resolved.mjs

@@ -21,14 +21,14 @@ import {
   setionLinesFromPropertyIterator
 } from "../utils.mjs";
 
-const SystemdResolvedServiceTypeDefinition = {
-  name: "systemd-resolved",
-  priority: 1,
-  extends: ExtraSourceServiceTypeDefinition,
-  specializationOf: ServiceTypeDefinition,
-  owners: ServiceTypeDefinition.owners,
-  key: "name",
-  attributes: {
+export class SystemdResolvedService extends ExtraSourceService {
+  static name = "systemd-resolved";
+  static priority = 1;
+  static extends = ExtraSourceServiceTypeDefinition;
+  static specializationOf = ServiceTypeDefinition;
+  static owners = ServiceTypeDefinition.owners;
+  static key = "name";
+  static attributes = {
     /* Resolve: {
       ...object_attribute,
       attributes: {*/
@@ -71,22 +71,20 @@ const SystemdResolvedServiceTypeDefinition = {
     LLMNR: { ...yesno_attribute_writable, configurable: true }
     /* }
     }*/
-  },
-  service: {
-    extends: ["dns","mdns","llmnr"],
+  };
+  static service = {
+    extends: ["dns", "mdns", "llmnr"],
     systemdService: "systemd-resolved.service"
-  }
-};
+  };
 
-export class SystemdResolvedService extends ExtraSourceService {
-  static typeDefinition = SystemdResolvedServiceTypeDefinition;
+  static typeDefinition = this;
   static {
     addType(this);
-    addServiceType(this.typeDefinition.service, this.typeDefinition.name);
+    addServiceType(this.service, this.name);
   }
 
   get type() {
-    return SystemdResolvedServiceTypeDefinition.name;
+    return this.constructor.name;
   }
 
   systemdConfigs(name) {

package/src/services/systemd-timesyncd.mjs

@@ -12,14 +12,14 @@ import {
 } from "pmcf";
 import { filterConfigurable, sectionLines } from "../utils.mjs";
 
-const SystemdTimesyncdServiceTypeDefinition = {
-  name: "systemd-timesyncd",
-  priority: 1,
-  extends: ExtraSourceServiceTypeDefinition,
-  specializationOf: ServiceTypeDefinition,
-  owners: ServiceTypeDefinition.owners,
+export class SystemdTimesyncdService extends ExtraSourceService {
+  static name = "systemd-timesyncd";
+  static priority = 1;
+  static extends = ExtraSourceServiceTypeDefinition;
+  static specializationOf = ServiceTypeDefinition;
+  static owners = ServiceTypeDefinition.owners;
 
-  attributes: {
+  static attributes = {
     NTP: { ...string_attribute_writable, configurable: true },
     FallbackNTP: { ...string_attribute_writable, configurable: true },
     RootDistanceMaxSec: { ...duration_attribute_writable, configurable: true },
@@ -27,21 +27,19 @@ const SystemdTimesyncdServiceTypeDefinition = {
     PollIntervalMaxSec: { ...duration_attribute_writable, configurable: true },
     ConnectionRetrySec: { ...duration_attribute_writable, configurable: true },
     SaveIntervalSec: { ...duration_attribute_writable, configurable: true }
-  },
-  service: {
+  };
+  static service = {
     systemdService: "systemd-timesyncd.service"
-  }
-};
+  };
 
-export class SystemdTimesyncdService extends ExtraSourceService {
-  static typeDefinition = SystemdTimesyncdServiceTypeDefinition;
+  static typeDefinition = this;
   static {
     addType(this);
-    addServiceType(this.typeDefinition.service, this.typeDefinition.name);
+    addServiceType(this.service, this.name);
   }
 
   get type() {
-    return SystemdTimesyncdServiceTypeDefinition.name;
+    return this.constructor.name;
   }
 
   systemdConfigs(name) {