pmcf 2.66.4 → 2.68.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pmcf",
-  "version": "2.66.4",
+  "version": "2.68.0",
   "publishConfig": {
     "access": "public"
   },
@@ -20,7 +20,10 @@
     "kea",
     "keepalived",
     "openldap",
-    "systemd"
+    "systemd",
+    "chrony",
+    "influxdb",
+    "openldap"
   ],
   "contributors": [
     {

package/src/module.mjs

@@ -22,6 +22,7 @@ export * from "./services/bind.mjs";
 export * from "./services/chrony.mjs";
 export * from "./services/kea.mjs";
 export * from "./services/openldap.mjs";
+export * from "./services/influxdb.mjs";
 export * from "./services/systemd-journal.mjs";
 export * from "./services/systemd-journal-remote.mjs";
 export * from "./services/systemd-journal-upload.mjs";

package/src/service.mjs

@@ -128,7 +128,9 @@ export class Service extends Base {
 
   endpoints(filter) {
     const data = serviceTypeEndpoints(this.type);
-
+    if (!data) {
+      return [];
+    }
     const l = this._port === undefined ? {} : { port: this._port };
     let result = [...this.host.networkAddresses()]
       .map(na => data.map(d => new Endpoint(this, na, { ...d, ...l })))

package/src/services/bind.mjs

@@ -16,13 +16,27 @@ import {
   addresses
 } from "pmcf";
 import { addType } from "../types.mjs";
-import { addServiceTypes } from "../service-types.mjs";
 import { Service, ServiceTypeDefinition } from "../service.mjs";
 import { ExtraSourceServiceTypeDefinition } from "../extra-source-service.mjs";
 import { addHook } from "../hooks.mjs";
 
 const address_types = ["network", "host", "network_interface"];
 
+const BindServiceTypes = {
+  "bind-statistics": {
+    endpoints: [
+      {
+        port: 19521,
+        protocol: "tcp",
+        tls: false
+      }
+    ]
+  },
+  rdnc: {
+    endpoints: [{ type: "rdnc", port: 953, protocol: "tcp", tls: false }]
+  }
+};
+
 const BindServiceTypeDefinition = {
   name: "bind",
   specializationOf: ServiceTypeDefinition,
@@ -87,25 +101,12 @@ const BindServiceTypeDefinition = {
     expire: { type: "string", collection: false, writeable: true },
     minimum: { type: "string", collection: false, writeable: true },
     allowedUpdates: { type: "string", collection: true, writeable: true }
-  }
-};
+  },
 
-const BindServiceTypes = {
-  [BindServiceTypeDefinition.name]: {
+  service: {
     extends: ["dns"]
   },
-  "bind-statistics": {
-    endpoints: [
-      {
-        port: 19521,
-        protocol: "tcp",
-        tls: false
-      }
-    ]
-  },
-  rdnc: {
-    endpoints: [{ type: "rdnc", port: 953, protocol: "tcp", tls: false }]
-  }
+  services: BindServiceTypes
 };
 
 const rdncEndpoint = BindServiceTypes.rdnc.endpoints[0];
@@ -142,7 +143,6 @@ export class BindService extends ExtraSourceService {
 
   static {
     addType(this);
-    addServiceTypes(BindServiceTypes);
   }
 
   static get typeDefinition() {

package/src/services/chrony.mjs

@@ -7,7 +7,6 @@ import {
   ExtraSourceServiceTypeDefinition
 } from "../extra-source-service.mjs";
 import { writeLines } from "../utils.mjs";
-import { addServiceTypes } from "../service-types.mjs";
 
 const ChronyServiceTypeDefinition = {
   name: "chrony",
@@ -15,11 +14,8 @@ const ChronyServiceTypeDefinition = {
   owners: ServiceTypeDefinition.owners,
   extends: ExtraSourceServiceTypeDefinition,
   priority: 0.1,
-  properties: {}
-};
-
-const ChronyServiceTypes = {
-  "chrony": {
+  properties: {},
+  service: {
     extends: ["ntp"]
   }
 };
@@ -27,7 +23,6 @@ const ChronyServiceTypes = {
 export class ChronyService extends ExtraSourceService {
   static {
     addType(this);
-    addServiceTypes(ChronyServiceTypes);
   }
 
   static get typeDefinition() {

package/src/services/influxdb.mjs

@@ -0,0 +1,39 @@
+import { addType } from "../types.mjs";
+import { Service, ServiceTypeDefinition } from "../service.mjs";
+
+const InfluxdbServiceTypeDefinition = {
+  name: "influxdb",
+  specializationOf: ServiceTypeDefinition,
+  owners: ServiceTypeDefinition.owners,
+  extends: ServiceTypeDefinition,
+  priority: 0.1,
+  properties: {},
+  service: {
+    endpoints: [
+      {
+        port: 8086,
+        protocol: "tcp",
+        tls: false
+      }
+    ]
+  }
+};
+
+export class InfluxdbService extends Service {
+  static {
+    addType(this);
+  }
+
+  static get typeDefinition() {
+    return InfluxdbServiceTypeDefinition;
+  }
+
+  constructor(owner, data) {
+    super(owner, data);
+    this.read(data, InfluxdbServiceTypeDefinition);
+  }
+
+  get type() {
+    return InfluxdbServiceTypeDefinition.name;
+  }
+}

package/src/services/kea.mjs

@@ -12,19 +12,9 @@ import {
   SUBNET_LOCALHOST_IPV4,
   SUBNET_LOCALHOST_IPV6
 } from "pmcf";
-import { addServiceTypes } from "../service-types.mjs";
 import { addType } from "../types.mjs";
 import { writeLines } from "../utils.mjs";
 
-const KeaServiceTypeDefinition = {
-  name: "kea",
-  specializationOf: ServiceTypeDefinition,
-  owners: ServiceTypeDefinition.owners,
-  extends: ServiceTypeDefinition,
-  priority: 0.1,
-  properties: {}
-};
-
 const ddnsEndpoint = {
   type: "kea-ddns",
   port: 53001,
@@ -74,28 +64,38 @@ const controlDDNSEndpoint = {
   path: "/run/kea/ddns-ctrl-socket"
 };
 
-const KEAServiceTypes = {
-  kea: { extends: ["dhcp"] },
-  "kea-ddns": {
-    endpoints: [ddnsEndpoint]
-  },
-  "kea-control-agent": {
-    endpoints: [controlAgentEndpoint]
-  },
-  "kea-ha-4": {
-    endpoints: [ha4Endpoint]
-  },
-  "kea-ha-6": {
-    endpoints: [ha6Endpoint]
-  },
-  "kea-control-dhcp4": {
-    endpoints: [control4Endpoint]
-  },
-  "kea-control-dhcp6": {
-    endpoints: [control6Endpoint]
+const KeaServiceTypeDefinition = {
+  name: "kea",
+  specializationOf: ServiceTypeDefinition,
+  owners: ServiceTypeDefinition.owners,
+  extends: ServiceTypeDefinition,
+  priority: 0.1,
+  properties: {},
+  service: {
+    extends: ["dhcp"]
   },
-  "kea-control-ddns": {
-    endpoints: [controlDDNSEndpoint]
+  services: {
+    "kea-ddns": {
+      endpoints: [ddnsEndpoint]
+    },
+    "kea-control-agent": {
+      endpoints: [controlAgentEndpoint]
+    },
+    "kea-ha-4": {
+      endpoints: [ha4Endpoint]
+    },
+    "kea-ha-6": {
+      endpoints: [ha6Endpoint]
+    },
+    "kea-control-dhcp4": {
+      endpoints: [control4Endpoint]
+    },
+    "kea-control-dhcp6": {
+      endpoints: [control6Endpoint]
+    },
+    "kea-control-ddns": {
+      endpoints: [controlDDNSEndpoint]
+    }
   }
 };
 
@@ -105,7 +105,6 @@ export const fetureHasHTTPEndpoints = keaVersion > 2.7;
 export class KeaService extends Service {
   static {
     addType(this);
-    addServiceTypes(KEAServiceTypes);
   }
 
   static get typeDefinition() {

package/src/services/openldap.mjs

@@ -13,7 +13,8 @@ const OpenLDAPServiceTypeDefinition = {
   owners: ServiceTypeDefinition.owners,
   extends: ServiceTypeDefinition,
   priority: 0.1,
-  properties: {}
+  properties: {},
+  service: {}
 };
 
 export class OpenLDAPService extends Service {

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

@@ -1,6 +1,5 @@
 import { Service, ServiceTypeDefinition } from "pmcf";
 import { addType } from "../types.mjs";
-import { addServiceTypes } from "../service-types.mjs";
 
 const SystemdJournalRemoteServiceTypeDefinition = {
   name: "systemd-journal-remote",
@@ -8,11 +7,8 @@ const SystemdJournalRemoteServiceTypeDefinition = {
   owners: ServiceTypeDefinition.owners,
   extends: ServiceTypeDefinition,
   priority: 0.1,
-  properties: {}
-};
-
-const SystemdJournalRemoteServiceTypes = {
-  [SystemdJournalRemoteServiceTypeDefinition.name]: {
+  properties: {},
+  services: {
     extends: ["http"],
     endpoints: [
       {
@@ -27,7 +23,6 @@ const SystemdJournalRemoteServiceTypes = {
 export class SystemdJournalRemoteService extends Service {
   static {
     addType(this);
-    addServiceTypes(SystemdJournalRemoteServiceTypes);
   }
 
   static get typeDefinition() {

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

@@ -9,7 +9,8 @@ const SystemdJournalUploadServiceTypeDefinition = {
   priority: 0.1,
   properties: {
     url: { type: "string", collection: false, writeable: true }
-  }
+  },
+  service: {}
 };
 
 export class SystemdJournalUploadService extends Service {

package/src/services/systemd-journal.mjs

@@ -7,7 +7,8 @@ const SystemdJournalServiceTypeDefinition = {
   owners: ServiceTypeDefinition.owners,
   extends: ServiceTypeDefinition,
   priority: 0.1,
-  properties: {}
+  properties: {},
+  service: {}
 };
 
 export class SystemdJournalService extends Service {

package/src/services/systemd-resolved.mjs

@@ -11,7 +11,8 @@ const SystemdResolvedServiceTypeDefinition = {
   owners: ServiceTypeDefinition.owners,
   extends: ServiceTypeDefinition,
   priority: 0.1,
-  properties: {}
+  properties: {},
+  service: {}
 };
 
 export class SystemdResolvedService extends ExtraSourceService {

package/src/services/systemd-timesyncd.mjs

@@ -11,7 +11,8 @@ const SystemdTimesyncdServiceTypeDefinition = {
   owners: ServiceTypeDefinition.owners,
   extends: ServiceTypeDefinition,
   priority: 0.1,
-  properties: {}
+  properties: {},
+  service: {}
 };
 
 export class SystemdTimesyncdService extends ExtraSourceService {

package/src/types.mjs

@@ -1,4 +1,5 @@
 import { asArray } from "./utils.mjs";
+import { addServiceTypes } from "./service-types.mjs";
 
 export const types = {};
 
@@ -9,6 +10,14 @@ export function addType(clazz) {
     type.specializationOf.specializations[type.name] = type;
   }
 
+  if (type.service) {
+    addServiceTypes({ [type.name]: type.service });
+  }
+
+  if (type.services) {
+    addServiceTypes(type.services);
+  }
+
   types[type.name] = type;
 
   type.clazz = clazz;

package/types/module.d.mts

@@ -22,6 +22,7 @@ export * from "./services/bind.mjs";
 export * from "./services/chrony.mjs";
 export * from "./services/kea.mjs";
 export * from "./services/openldap.mjs";
+export * from "./services/influxdb.mjs";
 export * from "./services/systemd-journal.mjs";
 export * from "./services/systemd-journal-remote.mjs";
 export * from "./services/systemd-journal-upload.mjs";

package/types/services/bind.d.mts

@@ -360,6 +360,26 @@ export class BindService extends ExtraSourceService {
                 writeable: boolean;
             };
         };
+        service: {
+            extends: string[];
+        };
+        services: {
+            "bind-statistics": {
+                endpoints: {
+                    port: number;
+                    protocol: string;
+                    tls: boolean;
+                }[];
+            };
+            rdnc: {
+                endpoints: {
+                    type: string;
+                    port: number;
+                    protocol: string;
+                    tls: boolean;
+                }[];
+            };
+        };
     };
     allowedUpdates: any[];
     recordTTL: string;

package/types/services/chrony.d.mts

@@ -264,6 +264,9 @@ export class ChronyService extends ExtraSourceService {
         };
         priority: number;
         properties: {};
+        service: {
+            extends: string[];
+        };
     };
     preparePackages(dir: any): AsyncGenerator<{
         dir: any;

package/types/services/influxdb.d.mts

@@ -0,0 +1,265 @@
+export class InfluxdbService 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: {
+                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;
+                };
+                types: {
+                    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: {
+                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;
+                };
+                types: {
+                    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: {};
+        service: {
+            endpoints: {
+                port: number;
+                protocol: string;
+                tls: boolean;
+            }[];
+        };
+    };
+    get type(): string;
+}
+import { Service } from "../service.mjs";

package/types/services/kea.d.mts

@@ -253,6 +253,67 @@ export class KeaService extends Service {
         };
         priority: number;
         properties: {};
+        service: {
+            extends: string[];
+        };
+        services: {
+            "kea-ddns": {
+                endpoints: {
+                    type: string;
+                    port: number;
+                    protocol: string;
+                    tls: boolean;
+                }[];
+            };
+            "kea-control-agent": {
+                endpoints: {
+                    type: string;
+                    port: number;
+                    pathname: string;
+                    protocol: string;
+                    tls: boolean;
+                }[];
+            };
+            "kea-ha-4": {
+                endpoints: {
+                    type: string;
+                    port: number;
+                    pathname: string;
+                    protocol: string;
+                    tls: boolean;
+                }[];
+            };
+            "kea-ha-6": {
+                endpoints: {
+                    type: string;
+                    port: number;
+                    pathname: string;
+                    protocol: string;
+                    tls: boolean;
+                }[];
+            };
+            "kea-control-dhcp4": {
+                endpoints: {
+                    type: string;
+                    family: string;
+                    path: string;
+                }[];
+            };
+            "kea-control-dhcp6": {
+                endpoints: {
+                    type: string;
+                    family: string;
+                    path: string;
+                }[];
+            };
+            "kea-control-ddns": {
+                endpoints: {
+                    type: string;
+                    family: string;
+                    path: string;
+                }[];
+            };
+        };
     };
     get type(): string;
     preparePackages(dir: any): AsyncGenerator<{

package/types/services/openldap.d.mts

@@ -252,6 +252,7 @@ export class OpenLDAPService extends Service {
         };
         priority: number;
         properties: {};
+        service: {};
     };
     get type(): string;
     preparePackages(dir: any): AsyncGenerator<{

package/types/services/systemd-journal-remote.d.mts

@@ -252,6 +252,14 @@ export class SystemdJournalRemoteService extends Service {
         };
         priority: number;
         properties: {};
+        services: {
+            extends: string[];
+            endpoints: {
+                port: number;
+                protocol: string;
+                tls: boolean;
+            }[];
+        };
     };
     get type(): string;
     get systemdServices(): string;

package/types/services/systemd-journal-upload.d.mts

@@ -258,6 +258,7 @@ export class SystemdJournalUploadService extends Service {
                 writeable: boolean;
             };
         };
+        service: {};
     };
     get type(): string;
     get systemdServices(): string;

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

@@ -252,6 +252,7 @@ export class SystemdJournalService extends Service {
         };
         priority: number;
         properties: {};
+        service: {};
     };
     get type(): string;
     get systemdServices(): string;

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

@@ -252,6 +252,7 @@ export class SystemdResolvedService extends ExtraSourceService {
         };
         priority: number;
         properties: {};
+        service: {};
     };
     get systemdServices(): string;
     systemdConfigs(name: any): {

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

@@ -252,6 +252,7 @@ export class SystemdTimesyncdService extends ExtraSourceService {
         };
         priority: number;
         properties: {};
+        service: {};
     };
     get systemdServices(): string;
     systemdConfigs(name: any): {