pmcf 4.30.7 → 5.0.0

package/src/services/systemd-journald.mjs

@@ -4,98 +4,120 @@ import { filterConfigurable, sectionLines } from "../utils.mjs";
 
 export class SystemdJournaldService extends Service {
   static name = "systemd-journald";
-  static specializationOf = Service;
   static attributes = {
     Storage: {
       ...string_attribute_writable,
+      name: "Storage",
       configurable: true
     },
     Seal: {
       ...string_attribute_writable,
+      name: "Seal",
       configurable: true
     },
     SplitMode: {
       ...string_attribute_writable,
+      name: "SplitMode",
       configurable: true
     },
     SyncIntervalSec: {
       ...duration_attribute_writable,
+      name: "SyncIntervalSec",
       configurable: true
     },
     RateLimitIntervalSec: {
       ...duration_attribute_writable,
+      name: "RateLimitIntervalSec",
       configurable: true
     },
     RateLimitBurst: {
       ...string_attribute_writable,
+      name: "RateLimitBurst",
       configurable: true
     },
     SystemMaxUse: {
       ...string_attribute_writable,
+      name: "SystemMaxUse",
       configurable: true
     },
     SystemKeepFree: {
       ...string_attribute_writable,
+      name: "SystemKeepFree",
       configurable: true
     },
     SystemMaxFileSize: {
       ...string_attribute_writable,
+      name: "SystemMaxFileSize",
       configurable: true
     },
     SystemMaxFiles: {
       ...string_attribute_writable,
+      name: "SystemMaxFiles",
       configurable: true
     },
     RuntimeMaxUse: {
       ...string_attribute_writable,
+      name: "RuntimeMaxUse",
       configurable: true
     },
     RuntimeKeepFree: {
       ...string_attribute_writable,
+      name: "RuntimeKeepFree",
       configurable: true
     },
     RuntimeMaxFileSize: {
       ...string_attribute_writable,
+      name: "RuntimeMaxFileSize",
       configurable: true
     },
     RuntimeMaxFiles: {
       ...string_attribute_writable,
+      name: "RuntimeMaxFiles",
       configurable: true
     },
     MaxRetentionSec: {
       ...duration_attribute_writable,
+      name: "MaxRetentionSec",
       configurable: true
     },
     MaxFileSec: {
       ...duration_attribute_writable,
+      name: "MaxFileSec",
       configurable: true
     },
     ForwardToSyslog: {
       ...string_attribute_writable,
+      name: "ForwardToSyslog",
       configurable: true
     },
     ForwardToKMsg: {
       ...string_attribute_writable,
+      name: "ForwardToKMsg",
       configurable: true
     },
     ForwardToConsole: {
       ...string_attribute_writable,
+      name: "ForwardToConsole",
       configurable: true
     },
     ForwardToWall: {
       ...string_attribute_writable,
+      name: "ForwardToWall",
       configurable: true
     },
     TTYPath: {
       ...string_attribute_writable,
+      name: "TTYPath",
       configurable: true
     },
     MaxLevelStore: {
       ...string_attribute_writable,
+      name: "MaxLevelStore",
       configurable: true
     },
     Compress: {
       ...string_attribute_writable,
+      name: "Compress",
       configurable: true
     }
   };

package/src/services/systemd-resolved.mjs

@@ -6,7 +6,7 @@ import {
   boolean_attribute_writable,
   yesno_attribute_writable
 } from "pacc";
-import { ExtraSourceService, serviceEndpoints, addType, Service } from "pmcf";
+import { ExtraSourceService, serviceEndpoints, addType } from "pmcf";
 import {
   filterConfigurable,
   yesno,
@@ -16,50 +16,72 @@ import {
 
 export class SystemdResolvedService extends ExtraSourceService {
   static name = "systemd-resolved";
-  static specializationOf = Service;
   static attributes = {
-    /* Resolve: {
-      ...object_attribute,
-      attributes: {*/
-    DNS: { ...string_attribute_writable, configurable: true },
-    FallbackDNS: { ...string_attribute_writable, configurable: true },
-
+    DNS: { ...string_attribute_writable, name: "DNS", configurable: true },
+    FallbackDNS: {
+      ...string_attribute_writable,
+      name: "FallbackDNS",
+      configurable: true
+    },
     domains: {
-      externalName: "Domains",
       ...string_collection_attribute_writable,
+      name: "domains",
+      externalName: "Domains",
       configurable: true
     },
-
-    MulticastDNS: { ...yesno_attribute_writable, configurable: true },
-    Cache: { ...boolean_attribute_writable, configurable: true },
+    MulticastDNS: {
+      ...yesno_attribute_writable,
+      name: "MulticastDNS",
+      configurable: true
+    },
+    Cache: { ...boolean_attribute_writable, name: "Cache", configurable: true },
     CacheFromLocalhost: {
       ...boolean_attribute_writable,
+      name: "CacheFromLocalhost",
+      configurable: true
+    },
+    DNSStubListener: {
+      ...boolean_attribute_writable,
+      name: "DNSStubListener",
       configurable: true
     },
-    DNSStubListener: { ...boolean_attribute_writable, configurable: true },
     DNSStubListenerExtra: {
       ...string_attribute_writable,
+      name: "DNSStubListenerExtra",
+      configurable: true
+    },
+    ReadEtcHosts: {
+      ...boolean_attribute_writable,
+      name: "ReadEtcHosts",
       configurable: true
     },
-    ReadEtcHosts: { ...boolean_attribute_writable, configurable: true },
     ResolveUnicastSingleLabel: {
       ...boolean_attribute_writable,
+      name: "ResolveUnicastSingleLabel",
       configurable: true
     },
     StaleRetentionSec: {
       ...duration_attribute_writable,
+      name: "StaleRetentionSec",
+      configurable: true
+    },
+    RefuseRecordTypes: {
+      ...string_attribute_writable,
+      name: "RefuseRecordTypes",
       configurable: true
     },
-    RefuseRecordTypes: { ...string_attribute_writable, configurable: true },
     DNSSEC: {
       ...yesno_attribute_writable,
+      name: "DNSSEC",
       default: false,
       configurable: true
     },
-    DNSOverTLS: { ...yesno_attribute_writable, configurable: true },
-    LLMNR: { ...yesno_attribute_writable, configurable: true }
-    /* }
-    }*/
+    DNSOverTLS: {
+      ...yesno_attribute_writable,
+      name: "DNSOverTLS",
+      configurable: true
+    },
+    LLMNR: { ...yesno_attribute_writable, name: "LLMNR", configurable: true }
   };
   static service = {
     extends: ["dns", "mdns", "llmnr"],

package/src/services/systemd-timesyncd.mjs

@@ -1,19 +1,41 @@
 import { string_attribute_writable, duration_attribute_writable } from "pacc";
-import { ExtraSourceService, Service, serviceEndpoints, addType } from "pmcf";
+import { ExtraSourceService, serviceEndpoints, addType } from "pmcf";
 import { filterConfigurable, sectionLines } from "../utils.mjs";
 
 export class SystemdTimesyncdService extends ExtraSourceService {
   static name = "systemd-timesyncd";
-  static specializationOf = Service;
-
   static attributes = {
-    NTP: { ...string_attribute_writable, configurable: true },
-    FallbackNTP: { ...string_attribute_writable, configurable: true },
-    RootDistanceMaxSec: { ...duration_attribute_writable, configurable: true },
-    PollIntervalMinSec: { ...duration_attribute_writable, configurable: true },
-    PollIntervalMaxSec: { ...duration_attribute_writable, configurable: true },
-    ConnectionRetrySec: { ...duration_attribute_writable, configurable: true },
-    SaveIntervalSec: { ...duration_attribute_writable, configurable: true }
+    NTP: { ...string_attribute_writable, name: "NTP", configurable: true },
+    FallbackNTP: {
+      ...string_attribute_writable,
+      name: "FallbackNTP",
+      configurable: true
+    },
+    RootDistanceMaxSec: {
+      ...duration_attribute_writable,
+      name: "RootDistanceMaxSec",
+      configurable: true
+    },
+    PollIntervalMinSec: {
+      ...duration_attribute_writable,
+      name: "PollIntervalMinSec",
+      configurable: true
+    },
+    PollIntervalMaxSec: {
+      ...duration_attribute_writable,
+      name: "PollIntervalMaxSec",
+      configurable: true
+    },
+    ConnectionRetrySec: {
+      ...duration_attribute_writable,
+      name: "ConnectionRetrySec",
+      configurable: true
+    },
+    SaveIntervalSec: {
+      ...duration_attribute_writable,
+      name: "SaveIntervalSec",
+      configurable: true
+    }
   };
   static service = {
     systemdService: "systemd-timesyncd.service"

package/src/services/tailscale.mjs

@@ -2,7 +2,6 @@ import { FAMILY_IPV4 } from "ip-utilties";
 import { Service, addType } from "pmcf";
 
 export class tailscale extends Service {
-  static specializationOf = Service;
   static service = {
     endpoints: [
       {

package/src/subnet.mjs

@@ -7,22 +7,21 @@ import {
   matchPrefixIP,
   FAMILY_IPV6
 } from "ip-utilties";
-import { string_attribute, name_attribute, number_attribute } from "pacc";
-import { networks_attribute } from "./network-support.mjs";
-import { Base } from "./base.mjs";
-import { addType } from "pmcf";
+import { string_attribute, name_attribute, integer_attribute } from "pacc";
+import { networks_attribute } from "./common-attributes.mjs";
+import { addType, Network } from "pmcf";
 
-export class Subnet extends Base {
+export class Subnet {
   static name = "subnet";
   static priority = 1;
-  static owners = ["location", "owner", "network", "root"];
+  static owners = ["owner", "network", "network_interface", "root"];
   static constructWithIdentifierOnly = true;
   static key = "address";
   static attributes = {
-    address: name_attribute,
+    address: { ...name_attribute, name: "address", private: true },
     networks: networks_attribute,
-    prefixLength: number_attribute,
-    family: string_attribute
+    prefixLength: { ...integer_attribute, name: "prefixLength" },
+    family: { ...string_attribute, name: "family" }
   };
 
   static {
@@ -31,24 +30,45 @@ export class Subnet extends Base {
 
   networks = new Set();
 
-  constructor(owner, address) {
+  constructor(address) {
     const { longPrefix, prefix, prefixLength, cidr } = normalizeCIDR(address);
-    super(owner, cidr);
 
+    this.address = cidr;
     this.prefix = prefix;
     this.prefixLength = prefixLength;
     this.longPrefix = longPrefix;
     this.family = familyIP(address);
+  }
+
+  get owner() {
+    return this._owner;
+  }
+
+  set owner(value) {
+    this._owner = value;
+    if(value instanceof Network) {
+      this.networks.add(value);
+    }
+  }
+
+  get children()
+  {
+    return [];
+  }
 
-    owner.addObject(this);
+  *_walkDirections(directions, seen) {
   }
 
   get cidr() {
-    return this.name;
+    return this.address;
   }
 
   get fullName() {
-    return this.name;
+    return this.address;
+  }
+
+  get name() {
+    return this.address;
   }
 
   matchesAddress(address) {
@@ -73,28 +93,12 @@ export class Subnet extends Base {
     ];
   }
 
-  get address() {
-    return this.name;
-  }
-
   get longAddress() {
     return `${this.longPrefix}/${this.prefixLength}`;
   }
 }
 
-const _owner = { addObject() {} };
-export const SUBNET_GLOBAL_IPV4 = new Subnet(_owner, "0.0.0.0/0");
-export const SUBNET_GLOBAL_IPV6 = new Subnet(_owner, "::0/0");
-export const SUBNET_LOCALHOST_IPV4 = new Subnet(_owner, "127.0.0.1/8");
-export const SUBNET_LOCALHOST_IPV6 = new Subnet(_owner, "::1/128");
-export const SUBNET_LINK_LOCAL_IPV6 = new Subnet(_owner, "fe80::/64");
-
-export function subnets(sources) {
-  let all = new Set();
-
-  for (const source of sources) {
-    all = all.union(source.subnets);
-  }
-
-  return all;
-}
+export const SUBNET_GLOBAL_IPV4 = new Subnet("0.0.0.0/0");
+export const SUBNET_GLOBAL_IPV6 = new Subnet("::0/0");
+export const SUBNET_LOCALHOST_IPV4 = new Subnet("127.0.0.1/8");
+export const SUBNET_LOCALHOST_IPV6 = new Subnet("::1/128");

package/src/type.mjs

@@ -1,5 +1,16 @@
-import { addType as addTypeBasic } from "pacc";
+import { addType as addTypeBasic, toInternal } from "pacc";
+import { normalizeIP } from "ip-utilties";
 import { addServiceType } from "pmcf";
+import { asArray } from "./utils.mjs";
+
+addTypeBasic({
+  name: "ip",
+  primitive: true,
+  asMapEntry: (attribute, value, object) => [
+    normalizeIP(value),
+    object.addSubnet(value)
+  ]
+});
 
 export function addType(type) {
   addTypeBasic(type);
@@ -8,3 +19,77 @@ export function addType(type) {
     addServiceType(type.service, type.name);
   }
 }
+
+function error(message, attribute) {
+  throw new Error(message, { cause: attribute.name });
+}
+
+export function assign(attribute, object, value) {
+  value = toInternal(value, attribute);
+  value ??= attribute.default;
+
+  if (value !== undefined) {
+    if (attribute.values) {
+      if (!attribute.values.has(value)) {
+        error("unkown value", attribute);
+      }
+    }
+
+    if (attribute.backpointer) {
+      assign(attribute.backpointer, value, object);
+    }
+
+    if (attribute.collection) {
+      const current = object[attribute.name];
+
+      //console.log("ASSIGN", object.fullName, attribute.name, value.name);
+      if (current) {
+        if (typeof current.set === "function") {
+          if (attribute.type.primitive) {
+            if (attribute.type.asMapEntry) {
+              for (const v of asArray(value)) {
+                const [key, value] = attribute.type.asMapEntry(
+                  attribute,
+                  v,
+                  object
+                );
+                current.set(key, value);
+              }
+            } else {
+              for (const v of asArray(value)) {
+                current.set(v, v);
+              }
+            }
+          } else {
+            current.set(value[attribute.type.key || "name"], value);
+          }
+        } else {
+          if (typeof current.add === "function") {
+            if (value instanceof Set) {
+              object[attribute.name] = current.union(value);
+            } else {
+              current.add(value);
+            }
+          } else {
+            if (Array.isArray(current)) {
+              if (Array.isArray(value)) {
+                current.push(...value);
+              } else {
+                current.push(value);
+              }
+            } else {
+              object[attribute.name][value[attribute.type.key]] = value;
+            }
+          }
+        }
+      } else {
+        object[attribute.name] =
+          attribute.constructor === value.constructor ? value : asArray(value);
+      }
+    } else {
+      object[attribute.name] = value;
+    }
+  }
+
+  return value;
+}

package/src/utils.mjs

@@ -9,7 +9,7 @@ export function yesno(flag) {
  * Appends default domain if name does not already have a domain.
  * @param {string} name
  * @param {string} [defaultDomain]
- * @returns {string|undefined}
+ * @returns {string}
  */
 export function domainName(name, defaultDomain) {
   const dcs = name.split(".");
@@ -118,7 +118,7 @@ export function asIterator(value) {
   return asArray(value);
 }
 
-export const filterConfigurable = (name, attribute) =>
+export const filterConfigurable = attribute =>
   !attribute.private && attribute.configurable;
 
 export function union(value, present = new Set()) {

package/src/location.mjs

@@ -1,48 +0,0 @@
-import { FileContentProvider } from "npm-pkgbuild";
-import { Owner, addType } from "pmcf";
-import { loadHooks } from "./hooks.mjs";
-
-export class Location extends Owner {
-  static name = "location";
-  static owners = [Owner, Location, "root"];
-  static attributes = {};
-
-  static {
-    addType(this);
-  }
-
-  get location() {
-    return this;
-  }
-
-  get network() {
-    return [...this.typeList("network")][0] || super.network;
-  }
-
-  async *preparePackages(dir) {
-    const packageData = {
-      sources: [
-        new FileContentProvider(dir + "/"),
-        new FileContentProvider(
-          { dir: this.directory, pattern: "location.json" },
-          { destination: "/etc/location/location.json" }
-        )
-      ],
-      outputs: this.outputs,
-      properties: {
-        name: `${this.typeName}-${this.name}`,
-        description: `${this.typeName} definitions for ${this.fullName}`,
-        access: "private",
-        dependencies: { jq: ">=1.6" },
-        provides: ["location"]
-      }
-    };
-
-    await loadHooks(
-      packageData,
-      new URL("location.install", import.meta.url).pathname
-    );
-
-    yield packageData;
-  }
-}