pmcf 4.30.8 → 5.0.0

package/src/host.mjs

@@ -1,17 +1,23 @@
 import { readFile } from "node:fs/promises";
 import { join } from "node:path";
 import { FileContentProvider } from "npm-pkgbuild";
+import { AggregatedMap } from "aggregated-map";
 import {
-  default_attribute_writable,
+  default_collection_attribute_writable,
   string_attribute,
   string_attribute_writable,
   string_set_attribute_writable,
   number_attribute_writable,
-  boolean_attribute_false
+  boolean_attribute_false,
+  priority_attribute
 } from "pacc";
-import { NetworkInterface, addresses, addType } from "pmcf";
+import { addresses, addType, assign } from "pmcf";
+import {
+  networkAddressAttributes,
+  networkInterfaces_attribute,
+  hosts_attribute
+} from "./common-attributes.mjs";
 import { ServiceOwner } from "./service-owner.mjs";
-import { networkAddressAttributes } from "./network-support.mjs";
 import { addHook } from "./hooks.mjs";
 import {
   domainFromDominName,
@@ -28,29 +34,29 @@ export class Host extends ServiceOwner {
   static priority = 1.9;
   static attributes = {
     ...networkAddressAttributes,
-    networkInterfaces: {
-      ...default_attribute_writable,
-      type: "network_interface",
-      collection: true
-    },
-    aliases: string_set_attribute_writable,
+    networkInterfaces: networkInterfaces_attribute,
+    aliases: { ...string_set_attribute_writable, name: "aliases" },
     os: {
       ...string_attribute_writable,
-      values: ["osx", "windows", "linux"]
+      name: "os",
+      values: new Set(["osx", "windows", "linux"])
     },
-    "machine-id": string_attribute_writable,
-    distribution: string_attribute_writable,
+    "machine-id": { ...string_attribute_writable, name: "machine-id" },
+    distribution: { ...string_attribute_writable, name: "distribution" },
     deployment: {
       ...string_attribute_writable,
-      values: ["production", "development"]
+      name: "deployment",
+      values: new Set(["production", "development"])
     },
-    weight: number_attribute_writable,
-    serial: string_attribute_writable,
-    vendor: string_attribute_writable,
-    keymap: string_attribute_writable,
+    priority: priority_attribute,
+    weight: { ...number_attribute_writable, name: "weight" },
+    serial: { ...string_attribute_writable, name: "serial" },
+    vendor: { ...string_attribute_writable, name: "vendor" },
+    keymap: { ...string_attribute_writable, name: "keymap" },
     chassis: {
       ...string_attribute_writable,
-      values: [
+      name: "chassis",
+      values: new Set([
         "phone",
         "tablet",
         "router",
@@ -64,23 +70,22 @@ export class Host extends ServiceOwner {
         "battery",
         "virtual",
         "dehumidifier"
-      ]
+      ])
     },
     architecture: {
       ...string_attribute_writable,
-      values: ["x86", "x86_64", "aarch64", "armv7", "riscv"]
+      name: "architecture",
+      values: new Set(["x86", "x86_64", "aarch64", "armv7", "riscv"])
     },
-    replaces: string_set_attribute_writable,
-    depends: string_set_attribute_writable,
-    provides: string_set_attribute_writable,
+    replaces: { ...string_set_attribute_writable, name: "replaces" },
+    depends: { ...string_set_attribute_writable, name: "depends" },
+    provides: { ...string_set_attribute_writable, name: "provides" },
     extends: {
-      ...default_attribute_writable,
-      type: Host,
-      collection: true,
-      owner: false
+      ...default_collection_attribute_writable,
+      name: "extends",
+      type: Host
     },
-    model: string_attribute,
-    isModel: boolean_attribute_false
+    model: { ...string_attribute, name: "model" }
   };
 
   static {
@@ -106,11 +111,12 @@ export class Host extends ServiceOwner {
     super.materializeExtends();
 
     for (const host of this.walkDirections(["extends"])) {
-      for (const [name, ni] of host.networkInterfaces) {
+      for (const ni of host.networkInterfaces.values()) {
         const present = this._networkInterfaces.get(ni.name);
 
         if (present) {
           present.extends.add(ni);
+          present.materializeExtends();
         } else {
           this.networkInterfaces = ni.forOwner(this);
         }
@@ -292,6 +298,9 @@ export class Host extends ServiceOwner {
     );
   }
 
+  /**
+   * @return {Set<string>}
+   */
   get domainNames() {
     return new Set(
       [
@@ -335,16 +344,6 @@ export class Host extends ServiceOwner {
     return [this];
   }
 
-  typeNamed(typeName, name) {
-    if (typeName === NetworkInterface.name) {
-      const ni = this._networkInterfaces.get(name);
-      if (ni) {
-        return ni;
-      }
-    }
-    return super.typeNamed(typeName, name);
-  }
-
   get network() {
     for (const ni of this.networkInterfaces.values()) {
       if (ni._kind !== "loopback" && ni._network) {
@@ -371,7 +370,8 @@ export class Host extends ServiceOwner {
     this._networkInterfaces.set(networkInterface.name, networkInterface);
 
     if (!this.isTemplate && networkInterface.network) {
-      networkInterface.network.hosts = this;
+      assign(hosts_attribute, networkInterface.network, this);
+      //networkInterface.network.hosts = this;
     }
   }
 
@@ -390,13 +390,9 @@ export class Host extends ServiceOwner {
   }
 
   get subnets() {
-    let all = new Set();
-
-    for (const networkInterface of this.networkInterfaces.values()) {
-      all = all.union(networkInterface.subnets);
-    }
-
-    return all;
+    return new AggregatedMap(
+      [...this.networkInterfaces.values()].map(ni => ni.subnets)
+    );
   }
 
   async publicKey(type = "ed25519") {
@@ -421,7 +417,7 @@ export class Host extends ServiceOwner {
     Object.assign(packageData.properties, {
       description: `${this.typeName} definitions for ${this.fullName}`,
       dependencies: [
-        `${this.location.typeName}-${this.location.name}`,
+        `${this.owner.typeName}-${this.owner.name}`,
         ...this.depends
       ],
       provides: [...this.provides],
@@ -440,9 +436,10 @@ export class Host extends ServiceOwner {
       await ni.systemdDefinitions(dir, packageData);
     }
 
-    await generateKnownHosts(this.owner.hosts, join(dir, "root", ".ssh"));
-
-    //console.log([...this.walkDirections(["extends"])].map(e => e.fullName));
+    await generateKnownHosts(
+      this.owner.hosts.values(),
+      join(dir, "root", ".ssh")
+    );
 
     for (const [name, service] of this.services) {
       if (service.systemdConfigs) {

package/src/initialization-context.mjs

@@ -1,9 +1,12 @@
 import { readFile, glob } from "node:fs/promises";
 import { join } from "node:path";
-import { toInternal, attributeIterator, types, resolveTypeLinks } from "pacc";
-import { asArray } from "./utils.mjs";
-import { Base } from "./base.mjs";
-import { root } from "./root.mjs";
+import {
+  extendingAttributeIterator,
+  types,
+  resolveTypeLinks,
+  create
+} from "pacc";
+import { Base, root, assign } from "pmcf";
 
 /**
  * Keeps track of all in flight object creations and loose ends during config initialization.
@@ -18,278 +21,174 @@ export class InitializationContext {
   }
 
   resolveOutstanding() {
-    nextOutstanding: for (let { object, attribute, name, value } of this
+    nextOutstanding: for (let { object, attribute, value } of this
       .outstandingResolves) {
       value = object.expand(value);
 
       for (const type of attribute.type.members || [attribute.type]) {
         for (const node of object.walkDirections(["this", "owner"])) {
-          const resolved = node.typeNamed(type.name, value);
+          const resolved = this.named(value, node);
           if (resolved) {
-            this.assign(object, name, attribute, resolved);
+            assign(attribute, object, resolved);
             continue nextOutstanding;
           }
         }
       }
 
       this.error(
-        `Unable to resolve "${value}" (${attribute.type.name}) for attribute ${name}`,
-        object.root.named(value)?.toString()
+        `Unknown ${attribute.name}(${attribute.type.name}): "${value}"`
       );
     }
   }
 
-  resolveLater(object, attribute, name, value) {
-    this.outstandingResolves.push({ object, attribute, name, value });
+  resolveLater(object, attribute, value) {
+    this.outstandingResolves.push({ object, attribute, value });
   }
 
   error(...args) {
     console.error(...args);
   }
 
-  assign(object, name, attribute, value) {
-    value = toInternal(value, attribute);
-    value ??= attribute.default;
-
+  instantiateAndAssign(object, attribute, value) {
+    if (attribute.type.primitive) {
+      return assign(attribute, object, value);
+    }
     if (value !== undefined) {
-      if (attribute.values) {
-        if (attribute.values.indexOf(value) < 0) {
-          this.error(name, "unknown value", value, attribute.values);
-        }
-      }
-
-      if (attribute.collection) {
-        const current = object[name];
-
-        switch (typeof current) {
-          case "undefined":
-            if (attribute.constructor === value.constructor) {
-              object[name] = value;
-            } else {
-              object[name] = asArray(value);
-            }
-            break;
-          case "object":
-            if (Array.isArray(current)) {
-              if (Array.isArray(value)) {
-                current.push(...value);
-              } else {
-                current.push(value);
-              }
-            } else {
-              if (current instanceof Set) {
-                if (value instanceof Set) {
-                  object[name] = current.union(value);
-                } else {
-                  /*if(name === 'extends') {
-                    console.log("EXT",object.fullName,value.fullName)
-                  }*/
-                  object[name].add(value);
-                }
-              } else if (current instanceof Map) {
-                const keyName = attribute.type.key;
-                if (keyName) {
-                  current.set(value[keyName], value);
-                } else {
-                  // TODO
-                  object[name] = value;
-                }
-              } else {
-                const keyName = attribute.type.key;
-                object[name][value[keyName]] = value;
-              }
-            }
-            break;
-          case "function":
-            if (value instanceof Base) {
-              object.addObject(value);
-            } else {
-              this.error("Unknown collection type", name, current);
-            }
-            break;
+      if (typeof value === "object") {
+        if (attribute.type && value instanceof attribute.type) {
+          return assign(attribute, object, value);
         }
       } else {
-        object[name] = value;
+        const present = this.named(value, object);
+
+        if (
+          present &&
+          (present.typeName === attribute.type.name ||
+            attribute.type.members?.has(present.typeName))
+        ) {
+          return assign(attribute, object, present);
+        } else {
+          if (attribute.type.constructWithIdentifierOnly) {
+            return assign(
+              attribute,
+              object,
+              create(attribute.type, object, value)
+            );
+          } else {
+            return this.resolveLater(object, attribute, value);
+          }
+        }
       }
+      return assign(
+        attribute,
+        object,
+        this.read(create(attribute.type, object, value), value)
+      );
     }
   }
 
-  instantiateAndAssign(object, name, attribute, value) {
-    if (attribute.type.primitive) {
-      this.assign(object, name, attribute, value);
-      return;
+  read(object, data, type = object.constructor) {
+    if (data?.properties) {
+      Object.assign(object.properties, data.properties);
     }
 
-    switch (typeof value) {
-      case "undefined":
-        return;
-
-      case "function":
-        this.error("Invalid value", name, value);
-        break;
-
-      case "boolean":
-      case "bigint":
-      case "number":
-      case "string":
-        {
-          let o;
+    for (const [path, attribute] of extendingAttributeIterator(
+      type,
+      attribute => attribute.writable
+    )) {
+      const name = path.join(".");
+      const value = object.expand(data[name]);
 
-          for (const type of attribute.type.members || [attribute.type]) {
-            o = object.typeNamed(type.name, value);
-            if (o) {
-              break;
+      if (attribute.collection) {
+        if (typeof value === "object") {
+          if (Array.isArray(value)) {
+            for (const v of value) {
+              this.instantiateAndAssign(object, attribute, v);
             }
-          }
-
-          if (o) {
-            this.assign(object, name, attribute, o);
           } else {
-            if (attribute.type.constructWithIdentifierOnly) {
-              o = new attribute.type(
-                object.ownerFor(attribute, value),
-                value
-              );
-              this.read(o, value);
-              object.addObject(o);
+            if (value instanceof Base) {
+              assign(attribute, object, value);
             } else {
-              this.resolveLater(object, attribute, name, value);
+              for (const [objectName, objectData] of Object.entries(value)) {
+                if (typeof objectData === "object") {
+                  objectData[attribute.type.key] = objectName;
+                }
+                this.instantiateAndAssign(object, attribute, objectData);
+              }
             }
           }
+          continue;
         }
-
-        break;
-
-      case "object":
-        if (attribute.type && value instanceof attribute.type) {
-          this.assign(object, name, attribute, value);
-        } else {
-          this.assign(
-            object,
-            name,
-            attribute,
-            this.typeFactory(
-              attribute.type,
-              object.ownerFor(attribute, value),
-              value
-            )
-          );
-        }
-        break;
+      }
+      this.instantiateAndAssign(object, attribute, value);
     }
-  }
 
-  typeFactory(type, owner, data) {
-    const factory = type.factoryFor?.(owner, data) || type;
-    const object = new factory(owner);
+    if (data.extends) {
+      object.materializeExtends();
+    }
 
-    this.read(object, data);
-    owner.addObject(object);
     return object;
   }
 
-  read(object, data, type = object.constructor) {
-    if (data?.properties) {
-      Object.assign(object.properties, data.properties);
-    }
-
-    this._read(object, data, type);
+  async load(fileName, type) {
+    const name = fileName.replace(/\/?([^\/]+\.json)?$/, "");
 
-    if (data.extends) {
-      object.materializeExtends();
+    const object = this.root.named(name);
+    if (object) {
+      return object;
     }
-  }
 
-  _read(object, data, type) {
-    if (type.extends) {
-      this._read(object, data, type.extends);
-    }
+    if (type === undefined) {
+      const tn = fileName.substring(name.length, fileName.length - 5);
 
-    for (const [path, attribute] of attributeIterator(type.attributes)) {
-      if (attribute.writable) {
-        const name = path.join(".");
-        const value = object.expand(data[name]);
+      type = types[tn];
 
-        if (attribute.collection) {
-          if (typeof value === "object") {
-            if (Array.isArray(value)) {
-              for (const v of value) {
-                this.instantiateAndAssign(object, name, attribute, v);
-              }
-            } else {
-              if (value instanceof Base) {
-                this.assign(object, name, attribute, value);
-              } else {
-                for (const [objectName, objectData] of Object.entries(value)) {
-                  if (typeof objectData === "object") {
-                    objectData[attribute.type.key] = objectName;
-                  }
-                  this.instantiateAndAssign(
-                    object,
-                    name,
-                    attribute,
-                    objectData
-                  );
-                }
-              }
-            }
-            continue;
-          }
+      if (!type) {
+        for (const type of Object.values(types).filter(type => type.fileName)) {
+          try {
+            return await this.load(fileName, type);
+          } catch {}
         }
-        this.instantiateAndAssign(object, name, attribute, value);
+
+        this.error(`No type for "${fileName}"`);
       }
     }
-  }
 
-  async loadType(name, type) {
     const data = JSON.parse(
-      await readFile(
-        join(this.directory, name, type.fileName),
-        "utf8"
-      )
+      await readFile(join(this.directory, name, type.fileName), "utf8")
     );
 
     let owner;
     if (name[0] === "/") {
       const parentName = name.replace(/\/[^\/]+$/, "");
+
       owner = await this.load(parentName);
+
+      if (!owner) {
+        this.error(`No Parent for "${name}" "${parentName}"`);
+        return;
+      }
+
       data.name = name.substring(owner.fullName.length + 1);
     } else {
       owner = this.root;
       data.name = name;
     }
 
-    const object = this.typeFactory(type, owner, data);
-
-    //console.log("LOAD", [name, type.name, owner.fullName, data.name, object.fullName]);
-
-    this.root.addTypeObject(type.name, name, object);
-
-    return object;
-  }
-
-  async load(name, options) {
-    name = name.replace(/\/?([^\/]+\.json)?$/, "");
-
-    const object = this.root.named(name);
-    if (object) {
-      return object;
-    }
+    for (const [path, attribute] of extendingAttributeIterator(
+      owner.constructor,
+      attribute => attribute.type === type && attribute.collection
+    )) {
+      const object = create(type, owner, data);
 
-    if (options?.type) {
-      return this.loadType(name, options.type);
-    } else {
-      for (const type of Object.values(types).filter(
-        type => type?.fileName
-      )) {
-        try {
-          return await this.loadType(name, type);
-        } catch {}
+      // set backointer early so that parent properties can be found during load
+      if (attribute.backpointer) {
+        assign(attribute.backpointer, object, owner);
       }
+      return assign(attribute, owner, this.read(object, data));
     }
 
-    const parentName = name.replace(/\/[^\/]$/, "");
-    return name === parentName ? this.root : this.load(parentName, options);
+    this.error(`No attribute to assign ${type.name} to ${owner.fullName}`);
   }
 
   async loadAll() {
@@ -300,14 +199,7 @@ export class InitializationContext {
         for await (const name of glob("**/" + type.fileName, {
           cwd: this.directory
         })) {
-          if (type === this.root.constructor) {
-            const data = JSON.parse(
-              await readFile(join(this.directory, name), "utf8")
-            );
-            this.root.properties = data.properties;
-          } else {
-            await this.load("/" + name, { type });
-          }
+          await this.load("/" + name, type);
         }
       }
     }
@@ -315,7 +207,9 @@ export class InitializationContext {
     this.resolveOutstanding();
   }
 
-  named(name) {
-    return this.root.named(name);
+  named(name, base) {
+    return name[0] === "/"
+      ? this.root.named(name.substring(1))
+      : base.named(name);
   }
 }

package/src/module.mjs

@@ -2,13 +2,12 @@ export * from "./type.mjs";
 export * from "./base.mjs";
 export * from "./cluster.mjs";
 export * from "./owner.mjs";
-export * from "./location.mjs";
 export * from "./root.mjs";
 export * from "./subnet.mjs";
 export * from "./service-owner.mjs";
 export * from "./network.mjs";
 export * from "./network-address.mjs";
-export * from "./network-support.mjs";
+export * from "./common-attributes.mjs";
 export * from "./host.mjs";
 export * from "./network-interfaces/network-interface.mjs";
 export * from "./network-interfaces/loopback.mjs";

package/src/network-address.mjs

@@ -56,8 +56,8 @@ export function addresses(sources, options) {
           if (typeof s === "string") {
             return s;
           }
-          if (options?.aggregate && s instanceof Owner && s.subnets) {
-            return [...s.subnets];
+          if (options?.aggregate && s instanceof Owner && s.subnets.size > 0) {
+            return [...s.subnets.keys()];
           }
 
           return s.networkAddresses

package/src/network-interfaces/ethernet.mjs

@@ -1,28 +1,20 @@
-import { default_attribute_writable, addType } from "pacc";
 import { NetworkInterface } from "./network-interface.mjs";
+import { addType } from "../type.mjs";
+import { networkInterfaces_attribute } from "../common-attributes.mjs";
 
 export class ethernet extends NetworkInterface {
-  static specializationOf = NetworkInterface;
   static attributes = {
     arpbridge: {
-      ...default_attribute_writable,
-      type: "network_interface",
-      collection: true,
-      owner: false
+      ...networkInterfaces_attribute,
+      name: "arpbridge"
     }
   };
 
+  static commonNamePattern = /^(eth|end|en)\d+$/;
+
   static {
     addType(this);
   }
 
-  static isCommonName(name) {
-    return name.match(/^eth\d+$/);
-  }
-
-  arpbridge;
-
-  get kind() {
-    return this.constructor.name;
-  }
+  arpbridge = new Map();
 }