pmcf 4.19.2 → 4.21.0

package/src/cluster.mjs

@@ -14,6 +14,7 @@ import { writeLines } from "./utils.mjs";
 
 const ClusterTypeDefinition = {
   name: "cluster",
+  priority: 1.5,
   owners: [Owner.typeDefinition, "network", "location", "root"],
   extends: Host.typeDefinition,
   key: "name",
@@ -39,18 +40,16 @@ const ClusterTypeDefinition = {
 };
 
 export class Cluster extends Host {
-  _masters = [];
-  _backups = [];
-  routerId = 100;
-  checkInterval = 60;
+  static typeDefinition = ClusterTypeDefinition;
 
   static {
     addType(this);
   }
 
-  static get typeDefinition() {
-    return ClusterTypeDefinition;
-  }
+  _masters = [];
+  _backups = [];
+  routerId = 100;
+  checkInterval = 60;
 
   set masters(value) {
     this._masters.push(value);
@@ -166,7 +165,7 @@ export class Cluster extends Host {
         cfg.push("}", "");
 
         for (const endpoint of serviceEndpoints(cluster, {
-          services: 'type="http"',
+          services: "services[types[http]]",
           endpoints: e =>
             e.networkInterface && e.networkInterface.kind !== "loopback"
         })) {
@@ -177,10 +176,13 @@ export class Cluster extends Host {
           cfg.push(`  protocol ${endpoint.protocol.toUpperCase()}`);
 
           for (const member of this.members) {
-            const memberService =
-              member.findService(`type="${endpoint.type}"`) ||
-              member.host.findService(`type="${endpoint.type}"`); // TODO
+            const memberService = Array.from(
+              member.expression(
+                `aggregatedServices[types[${endpoint.type}]][0]`
+              )
+            );
 
+            console.log(member.fullName, endpoint.type, memberService);
             cfg.push(`  real_server ${member.address} ${memberService.port} {`);
             cfg.push(`    weight ${memberService.weight}`);
 

package/src/extra-source-service.mjs

@@ -17,25 +17,22 @@ export const ExtraSourceServiceTypeDefinition = {
 };
 
 export class ExtraSourceService extends Service {
-  source = [];
+  static typeDefinition = ExtraSourceServiceTypeDefinition;
 
   static {
     addType(this);
   }
 
-  static get typeDefinition() {
-    return ExtraSourceServiceTypeDefinition;
-  }
+  source = [];
 
   get type() {
     return ExtraSourceServiceTypeDefinition.name;
   }
 
-  *findServices(filter) {
-    yield* this.owner.owner.findServices(filter);
-
-    for (const s of this.source) {
-      yield* s.findServices(filter);
-    }
+  get services() {
+    return [
+      this.owner.owner.services,
+      ...this.source.map(s => s.services)
+    ].flat();
   }
 }

package/src/host.mjs

@@ -26,6 +26,7 @@ import { NetworkInterfaceTypeDefinition } from "./network-interfaces/network-int
 
 const HostTypeDefinition = {
   name: "host",
+  priority: 1.9,
   owners: ["owner", "network", "root"],
   extends: Base.typeDefinition,
   key: "name",
@@ -76,7 +77,7 @@ const HostTypeDefinition = {
     },
     architecture: {
       ...string_attribute_writable,
-      values: ["x86", "x86_64", "aarch64", "armv7"]
+      values: ["x86", "x86_64", "aarch64", "armv7", "riscv"]
     },
     replaces: string_set_attribute_writable,
     depends: string_set_attribute_writable,
@@ -88,6 +89,12 @@ const HostTypeDefinition = {
 };
 
 export class Host extends ServiceOwner {
+  static typeDefinition = HostTypeDefinition;
+
+  static {
+    addType(this);
+  }
+
   _aliases = new Set();
   _networkInterfaces = new Map();
   _provides = new Set();
@@ -102,29 +109,19 @@ export class Host extends ServiceOwner {
   _serial;
   _keymap;
 
-  static {
-    addType(this);
-  }
+  materializeExtends() {
+    super.materializeExtends();
 
-  static get typeDefinition() {
-    return HostTypeDefinition;
-  }
-
-  read(data, type) {
-    super.read(data, type);
-
-    this.extra = data.extra;
-  }
+    for (const host of this.walkDirections(["extends"])) {
+      for (const [name, ni] of host.networkInterfaces) {
+        const present = this._networkInterfaces.get(name);
 
-  _applyExtends(host) {
-    super._applyExtends(host);
-    for (const [name, ni] of host.networkInterfaces) {
-      const present = this._networkInterfaces.get(name);
-
-      if (present) {
-        present.extends.push(ni);
-      } else {
-        this._networkInterfaces.set(name, ni.forOwner(this));
+        if (present) {
+          //console.log("LINK", present.fullName, ni.fullName,present.extends);
+          present.extends.add(ni);
+        } else {
+          this._networkInterfaces.set(name, ni.forOwner(this));
+        }
       }
     }
   }
@@ -171,6 +168,13 @@ export class Host extends ServiceOwner {
     return this.extendedAttribute("_vendor");
   }
 
+  /**
+   * @return {string}
+   */
+  get id() {
+    return this["machine-id"];
+  }
+
   set keymap(value) {
     this._keymap = value;
   }
@@ -188,7 +192,9 @@ export class Host extends ServiceOwner {
   }
 
   get derivedPackaging() {
-    return this.extends.reduce((a, c) => a.union(c.packaging), new Set());
+    return this.expand(
+      this.collectFromDirections(["this", "extends"], "_packaging")
+    );
   }
 
   get isTemplate() {
@@ -200,7 +206,11 @@ export class Host extends ServiceOwner {
   }
 
   get model() {
-    return this.extends.find(h => h.isModel);
+    for (const node of this.walkDirections(["this", "extends"])) {
+      if (node.isModel) {
+        return node;
+      }
+    }
   }
 
   set aliases(value) {
@@ -208,7 +218,9 @@ export class Host extends ServiceOwner {
   }
 
   get aliases() {
-    return this.extends.reduce((a, c) => a.union(c.aliases), this._aliases);
+    return this.expand(
+      this.collectFromDirections(["this", "extends"], "_aliases")
+    );
   }
 
   set provides(value) {
@@ -217,7 +229,7 @@ export class Host extends ServiceOwner {
 
   get provides() {
     return this.expand(
-      this.extends.reduce((a, c) => a.union(c.provides), this._provides)
+      this.collectFromDirections(["this", "extends"], "_provides")
     );
   }
 
@@ -227,7 +239,7 @@ export class Host extends ServiceOwner {
 
   get replaces() {
     return this.expand(
-      this.extends.reduce((a, c) => a.union(c.replaces), this._replaces)
+      this.collectFromDirections(["this", "extends"], "_replaces")
     );
   }
 
@@ -237,7 +249,7 @@ export class Host extends ServiceOwner {
 
   get depends() {
     return this.expand(
-      this.extends.reduce((a, c) => a.union(c.depends), this._depends)
+      this.collectFromDirections(["this", "extends"], "_depends")
     );
   }
 
@@ -445,13 +457,13 @@ export class Host extends ServiceOwner {
       await ni.systemdDefinitions(dir, packageData);
     }
 
-    if (this.keymap) {
-      await writeLines(dir, "etc/vconsole.conf", `KEYMAP=${this.keymap}`);
-    }
-
     await generateKnownHosts(this.owner.hosts, join(dir, "root", ".ssh"));
 
+    console.log([...this.walkDirections(["extends"])].map(e => e.fullName));
+
     for (const service of this.services) {
+      //console.log("SERVICE",service.name);
+
       if (service.systemdConfigs) {
         for (const { serviceName, configFileName, content } of asArray(
           service.expand(service.systemdConfigs(this.name))
@@ -468,23 +480,5 @@ export class Host extends ServiceOwner {
     }
 
     yield packageData;
-
-    if (this.extra) {
-      yield {
-        sources: [
-          new FileContentProvider({
-            dir: join(this.directory, "extra"),
-            pattern: "**/*"
-          })
-        ],
-        outputs: this.outputs,
-        properties: {
-          name: `${this.typeName}-extra-${this.owner.name}-${this.name}`,
-          description: `additional files for ${this.fullName}`,
-          access: "private",
-          dependencies: [packageData.properties.name]
-        }
-      };
-    }
   }
 }

package/src/initialization-context.mjs

@@ -0,0 +1,324 @@
+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";
+
+/**
+ * Keeps track of all in flight object creations and loose ends during config initialization.
+ */
+export class InitializationContext {
+  outstandingResolves = [];
+
+  constructor(directory = "/") {
+    resolveTypeLinks();
+    this.directory = directory;
+    this.root = new Root(directory);
+  }
+
+  resolveOutstanding() {
+    for (let { object, attribute, name, value } of this.outstandingResolves) {
+      value = object.expand(value);
+
+      for (const type of attribute.type.members || [attribute.type]) {
+        const o =
+          object.typeNamed(type.name, value) ||
+          object.owner.typeNamed(type.name, value) ||
+          object.root.typeNamed(type.name, value); // TODO
+
+        if (o) {
+          this.assign(object, name, attribute, o);
+        }
+      }
+
+      /*
+      this.error(
+        `No such object "${value}" (${attribute.type.name}) for attribute ${name}`,
+        object.root.named(value)?.toString()
+      );*/
+    }
+  }
+
+  resolveLater(object, attribute, name, value) {
+    this.outstandingResolves.push({ object, attribute, name, value });
+  }
+
+  error(...args) {
+    console.error(...args);
+  }
+
+  assign(object, name, attribute, value) {
+    value = toInternal(value, attribute);
+    value ??= attribute.default;
+
+    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 {
+                  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;
+        }
+      } else {
+        object[name] = value;
+      }
+    }
+  }
+
+  instantiateAndAssign(object, name, attribute, value) {
+    if (attribute.type.primitive) {
+      this.assign(object, name, attribute, value);
+      return;
+    }
+
+    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 type of attribute.type.members || [attribute.type]) {
+            o = object.typeNamed(type.name, value);
+            if (o) {
+              break;
+            }
+          }
+
+          if (o) {
+            this.assign(object, name, attribute, o);
+          } else {
+            if (attribute.type.constructWithIdentifierOnly) {
+              o = new attribute.type.clazz(
+                object.ownerFor(attribute, value),
+                value
+              );
+              this.read(o, value);
+              object.addObject(o);
+            } else {
+              this.resolveLater(object, attribute, name, value);
+            }
+          }
+        }
+
+        break;
+
+      case "object":
+        if (attribute.type.clazz && value instanceof attribute.type.clazz) {
+          this.assign(object, name, attribute, value);
+        } else {
+          this.assign(
+            object,
+            name,
+            attribute,
+            this.typeFactory(
+              attribute.type,
+              object.ownerFor(attribute, value),
+              value
+            )
+          );
+        }
+        break;
+    }
+  }
+
+  typeFactory(type, owner, data) {
+    const factory = type.factoryFor?.(owner, data) || type.clazz;
+    const object = new factory(owner);
+
+    this.read(object, data);
+    owner.addObject(object);
+    return object;
+  }
+
+  read(object, data, type = object.constructor.typeDefinition) {
+    if (data?.properties) {
+      Object.assign(object._properties, data.properties);
+    }
+
+    for (const [path, attribute] of attributeIterator(type.attributes)) {
+      if (attribute.writable) {
+        const name = path.join(".");
+        const value = object.expand(data[name]);
+
+        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") {
+                    //console.log("KEY", objectName, type.name, type.key);
+                    objectData[attribute.type.key] = objectName;
+                  }
+                  this.instantiateAndAssign(
+                    object,
+                    name,
+                    attribute,
+                    objectData
+                  );
+                }
+              }
+            }
+            continue;
+          }
+        }
+        this.instantiateAndAssign(object, name, attribute, value);
+      }
+    }
+
+    if (object.name === undefined && data.name) {
+      // TODO
+      object.name = data.name;
+    }
+
+    if (type.extends) {
+      //console.log("READ EXTENDS",data);
+      this.read(object, data, type.extends);
+      object.materializeExtends();
+    }
+  }
+
+  async loadType(name, type) {
+    const data = JSON.parse(
+      await readFile(
+        join(this.directory, name, type.clazz.typeFileName),
+        "utf8"
+      )
+    );
+
+    //console.log("LOAD", name);
+    let owner;
+    if (name[0] === "/") {
+      const parentName = name.replace(/\/[^\/]+$/, "");
+      owner = await this.load(parentName);
+      data.name = name.substring(owner.fullName.length + 1);
+    } else {
+      owner = this.root;
+      data.name = name;
+    }
+
+    //console.log("LOAD", [name, owner.fullName, data.name]);
+
+    const object = this.typeFactory(type, owner, data);
+    this.root.addTypeObject(type.clazz.typeName, name, object);
+
+    /*if(object.name === undefined || object.name.length === 0) {
+      throw "NO name";
+    }*/
+
+    return object;
+  }
+
+  async load(name, options) {
+    name = name.replace(/\/?([^\/]+\.json)?$/, "");
+
+    const object = this.root.named(name);
+    if (object) {
+      return object;
+    }
+
+    if (options?.type) {
+      return this.loadType(name, options.type);
+    } else {
+      for (const type of Object.values(types).filter(
+        type => type?.clazz?.typeFileName
+      )) {
+        try {
+          return await this.loadType(name, type);
+        } catch {}
+      }
+    }
+
+    const parentName = name.replace(/\/[^\/]$/, "");
+    return name === parentName ? this.root : this.load(parentName, options);
+  }
+
+  async loadAll() {
+    for (const type of Object.values(types).sort(
+      (a, b) => b.priority - a.priority
+    )) {
+      //console.log("LIST","**/" + type.clazz.typeFileName);
+      if (type.clazz?.typeFileName) {
+        for await (const name of glob("**/" + type.clazz.typeFileName, {
+          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 });
+          }
+        }
+      }
+    }
+
+    this.resolveOutstanding();
+  }
+
+  named(name) {
+    return this.root.named(name);
+  }
+}

package/src/location.mjs

@@ -5,34 +5,24 @@ import { loadHooks } from "./hooks.mjs";
 
 const LocationTypeDefinition = {
   name: "location",
+  priority: 2,
   owners: [Owner.typeDefinition, "location", "root"],
   extends: Owner.typeDefinition,
   key: "name",
-  attributes: {
-  }
+  attributes: {}
 };
 
 export class Location extends Owner {
+  static typeDefinition = LocationTypeDefinition;
+
   static {
     addType(this);
   }
 
-  static get typeDefinition() {
-    return LocationTypeDefinition;
-  }
-
   get location() {
     return this;
   }
 
-  locationNamed(name) {
-    if (this.isNamed(name)) {
-      return this;
-    }
-
-    return super.locationNamed(name);
-  }
-
   get network() {
     return [...this.typeList("network")][0] || super.network;
   }

package/src/module.mjs

@@ -34,3 +34,4 @@ export * from "./services/systemd-journal-remote.mjs";
 export * from "./services/systemd-journal-upload.mjs";
 export * from "./services/systemd-timesyncd.mjs";
 export * from "./services/systemd-resolved.mjs";
+export * from "./initialization-context.mjs";

package/src/network-interfaces/ethernet.mjs

@@ -20,20 +20,18 @@ export const EthernetNetworkInterfaceTypeDefinition = {
 };
 
 export class EthernetNetworkInterface extends NetworkInterface {
-  arpbridge;
+  static typeDefinition = EthernetNetworkInterfaceTypeDefinition;
 
   static {
     addType(this);
   }
 
-  static get typeDefinition() {
-    return EthernetNetworkInterfaceTypeDefinition;
-  }
-
   static isCommonName(name) {
     return name.match(/^eth\d+$/);
   }
 
+  arpbridge;
+
   get kind() {
     return EthernetNetworkInterfaceTypeDefinition.name;
   }

package/src/network-interfaces/loopback.mjs

@@ -19,14 +19,12 @@ const _localAddresses = new Map([
 const _localDomains = new Set(["localhost"]);
 
 export class LoopbackNetworkInterface extends SkeletonNetworkInterface {
+  static typeDefinition = LoopbackNetworkInterfaceTypeDefinition;
+
   static {
     addType(this);
   }
 
-  static get typeDefinition() {
-    return LoopbackNetworkInterfaceTypeDefinition;
-  }
-
   static isCommonName(name) {
     return name.match(/^lo\d*$/);
   }