pmcf 6.37.2 → 6.38.1

package/src/core.mjs

@@ -0,0 +1,325 @@
+import { AggregatedMap } from "aggregated-map";
+
+import {
+  toExternal,
+  filterPublic,
+  parse,
+  extendingAttributeIterator,
+  getAttribute,
+  expand,
+  globals
+} from "pacc";
+import { addType } from "pmcf";
+
+export class Core {
+  static name = "core";
+  static priority = 1;
+
+  static {
+    addType(this);
+  }
+
+  extends = new Set();
+
+  constructor(owner, data) {
+    if (owner) {
+      this.owner = owner;
+    }
+  }
+
+  set owner(value) {
+    if (this === value || this === value?.owner) {
+      this.error("Unable to own myself", value.fullName);
+    } else {
+      this._owner = value;
+    }
+  }
+
+  get owner() {
+    return this._owner;
+  }
+
+  forOwner(owner) {
+    if (this.owner !== owner) {
+      const newObject = Object.create(this);
+      newObject.owner = owner;
+      return newObject;
+    }
+
+    return this;
+  }
+
+  materializeExtends() {
+    for (const [path, attribute] of extendingAttributeIterator(
+      this.constructor,
+      attribute => attribute.collection && !attribute.type.primitive
+    )) {
+      if (attribute.deferredExpression) {
+        const name = attribute.name;
+        if (!this.hasOwnProperty(name)) {
+          for (const e of this.walkDirections(["extends"])) {
+            if (e.hasOwnProperty(name)) {
+              Object.defineProperty(this, name, {
+                get: () => e[name]
+              });
+              break;
+            }
+          }
+        }
+
+        continue;
+      }
+
+      const collection = this[attribute.name];
+
+      if (typeof collection?.get === "function") {
+        for (const [name, extending] of this.mapFromDirections(
+          ["extends"],
+          attribute.name
+        )) {
+          const present = collection.get(extending.name);
+
+          if (present) {
+            present.extends.add(extending);
+            present.materializeExtends();
+          } else {
+            collection.set(extending.name, extending.forOwner(this));
+          }
+        }
+      } /*else {
+        if (Array.isArray(collection)) {
+          // TODO
+        } else {
+          //console.log("EXTENDS", this.fullName, attribute.name);
+
+          for (const extending of this.unionFromDirections(
+            ["extends"],
+            attribute.name
+          )) {
+            if (!collection.has(extending)) {
+              //console.log("ADD", this.fullName, extending.fullName);
+              collection.add(extending);
+            }
+          }
+        }
+      }*/
+    }
+  }
+
+  get typeName() {
+    return this.constructor.name;
+  }
+
+  /**
+   * Retrive attribute values from an object.
+   * @param {Function} [filter]
+   * @return {Iterable<[string,any]>} values
+   */
+  *attributeIterator(filter) {
+    for (const [path, attribute] of extendingAttributeIterator(
+      this.constructor,
+      filter
+    )) {
+      const name = path.join(".");
+      const value = this.attribute(name);
+
+      if (value !== undefined) {
+        yield [
+          attribute.externalName ?? name,
+          toExternal(value, attribute),
+          path,
+          attribute
+        ];
+      }
+    }
+  }
+
+  /**
+   * Retrive attribute values from an object.
+   * @param {Function} [filter]
+   * @return {Object} values
+   */
+  getAttributes(filter = filterPublic) {
+    return Object.fromEntries(this.attributeIterator(filter));
+  }
+
+  value(name) {
+    return this.attribute(name);
+  }
+
+  /**
+   *
+   * @param {string} name
+   * @returns {any}
+   */
+  property(name) {
+    for (const node of this.walkDirections()) {
+      const value = node.properties[name];
+
+      if (value !== undefined) {
+        return this.expand(value);
+      }
+    }
+  }
+
+  /**
+   *
+   * @param {string} name
+   * @returns {any}
+   */
+  attribute(name) {
+    for (const node of this.walkDirections(["this", "extends"])) {
+      const value = getAttribute(node, name);
+      if (value !== undefined) {
+        return this.expand(value);
+      }
+    }
+  }
+
+  /**
+   * Walk the object graph in some directions and deliver seen nodes.
+   * @param {string[]} directions
+   * @return {Iterable<Core>}
+   */
+  *walkDirections(directions = ["this", "extends", "owner"]) {
+    if (directions.indexOf("this") >= 0) {
+      yield this;
+      directions = directions.filter(d => d !== "this");
+    }
+
+    yield* this._walkDirections(directions, new Set());
+  }
+
+  *_walkDirections(directions, seen) {
+    if (!seen.has(this)) {
+      seen.add(this);
+
+      for (const direction of directions) {
+        const value = this[direction];
+
+        if (value) {
+          if (value[Symbol.iterator]) {
+            for (const node of value) {
+              yield node;
+              yield* node._walkDirections(directions, seen);
+            }
+          } else {
+            yield value;
+            yield* value._walkDirections(directions, seen);
+          }
+        }
+      }
+    }
+  }
+
+  /**
+   * Deliver AggregatedMap of all property Maps.
+   * @param {string[]} directions
+   * @param {string} property
+   * @returns {Map<any,any>}
+   */
+  mapFromDirections(directions, property) {
+    return new AggregatedMap(
+      [...this.walkDirections(directions)]
+        .map(node => node[property])
+        .filter(node => node !== undefined)
+    );
+  }
+
+  /**
+   * Deliver union set of all property values.
+   * @param {string[]} directions
+   * @param {string} property
+   * @returns {Set<any>}
+   */
+  unionFromDirections(directions, property) {
+    let collected = new Set();
+    for (const node of this.walkDirections(directions)) {
+      const value = node[property];
+      if (value !== undefined) {
+        if (!(value instanceof Set)) {
+          console.log("NO SET", value, node.fullName, property);
+        }
+        collected = collected.union(value);
+      }
+    }
+
+    return collected;
+  }
+
+  get children() {
+    const all = [];
+
+    for (const [path, attribute] of extendingAttributeIterator(
+      this.constructor,
+      attribute => attribute.backpointer?.name === "owner"
+    )) {
+      const value = this[path];
+
+      if (value !== undefined) {
+        if (attribute.collection) {
+          if (typeof value.values === "function") {
+            all.push(...value.values());
+          } else {
+            if (value instanceof Iterator) {
+              all.push(...value);
+            } else {
+              if (value instanceof Core) {
+                this.error(
+                  `Unexpected scalar value for "${attribute.name}"`,
+                  value.fullName
+                );
+                all.push(value); // TODO should not happen
+              } else if (typeof value === "object") {
+                all.push(...Object.values(value));
+              }
+            }
+          }
+        } else {
+          all.push(value);
+        }
+      }
+    }
+
+    return all;
+  }
+
+  /**
+   *
+   * @param {any} object
+   * @returns {any}
+   */
+  expand(object) {
+    if (this.isTemplate || object instanceof Core) {
+      return object;
+    }
+
+    return expand(object, {
+      stopClass: Core,
+      root: this.root,
+      current: this,
+      valueFor: (name, at) =>
+        typeof at?.value === "function" ? at.value(name) : globals[name]
+    });
+  }
+
+  /**
+   *
+   * @param {string} expression
+   * @param {object} options
+   * @returns {any}
+   */
+  expression(expression, options) {
+    return parse(expression, {
+      root: this.root,
+      current: this,
+      valueFor: (name, at) =>
+        typeof at?.value === "function" ? at.value(name) : globals[name],
+      ...options
+    });
+  }
+
+  get isTemplate() {
+    return false;
+  }
+}

package/src/host.mjs

@@ -5,7 +5,6 @@ import { AggregatedMap } from "aggregated-map";
 import {
   string_attribute,
   string_attribute_writable,
-  string_set_attribute_writable,
   number_attribute_writable,
   priority_attribute,
   asArray
@@ -19,12 +18,7 @@ import {
 } from "./common-attributes.mjs";
 import { ServiceOwner } from "./service-owner.mjs";
 import { addHook } from "./hooks.mjs";
-import {
-  domainFromDominName,
-  domainName,
-  writeLines,
-  union
-} from "./utils.mjs";
+import { domainFromDominName, domainName, writeLines } from "./utils.mjs";
 import { loadHooks } from "./hooks.mjs";
 import { generateKnownHosts } from "./host-utils.mjs";
 
@@ -75,10 +69,6 @@ export class Host extends ServiceOwner {
       name: "architecture",
       values: new Set(["x86", "x86_64", "aarch64", "armv7", "riscv"])
     },
-    replaces: { ...string_set_attribute_writable, name: "replaces" },
-    depends: { ...string_set_attribute_writable, name: "depends" },
-    provides: { ...string_set_attribute_writable, name: "provides" },
-    optional: { ...string_set_attribute_writable, name: "optional" },
     extends: {
       ...extends_attribute,
       type: Host
@@ -91,10 +81,6 @@ export class Host extends ServiceOwner {
   }
 
   _networkInterfaces = new Map();
-  _provides = new Set();
-  _replaces = new Set();
-  _depends = new Set();
-  _optional = new Set();
   _os;
   _distribution;
   _deployment;
@@ -152,12 +138,6 @@ export class Host extends ServiceOwner {
     return this.attribute("_architecture");
   }
 
-  get derivedPackaging() {
-    return this.expand(
-      this.unionFromDirections(["this", "extends"], "_packaging")
-    );
-  }
-
   get isTemplate() {
     return this.isModel || super.isTemplate;
   }
@@ -174,46 +154,6 @@ export class Host extends ServiceOwner {
     }
   }
 
-  set provides(value) {
-    this._provides = union(value, this._provides);
-  }
-
-  get provides() {
-    return this.expand(
-      this.unionFromDirections(["this", "extends"], "_provides")
-    );
-  }
-
-  set replaces(value) {
-    this._replaces = union(value, this._replaces);
-  }
-
-  get replaces() {
-    return this.expand(
-      this.unionFromDirections(["this", "extends"], "_replaces")
-    );
-  }
-
-  set depends(value) {
-    this._depends = union(value, this._depends);
-  }
-
-  get depends() {
-    return this.expand(
-      this.unionFromDirections(["this", "extends"], "_depends")
-    );
-  }
-
-  set optional(value) {
-    this._optional = union(value, this._optional);
-  }
-
-  get optional() {
-    return this.expand(
-      this.unionFromDirections(["this", "extends"], "_optional")
-    );
-  }
-
   set os(value) {
     this._os = value;
   }
@@ -365,34 +305,20 @@ export class Host extends ServiceOwner {
   }
 
   async publicKey(type = "ed25519") {
-    return readFile(join(this.directory, `ssh_host_${type}_key.pub`), "utf8");
+    return readFile(
+      join(this.directory, "content", "etc", "ssh", `ssh_host_${type}_key.pub`),
+      "utf8"
+    );
   }
 
   async *preparePackages(dir) {
     const packageData = this.packageData;
+
     packageData.sources.push(
       await Array.fromAsync(this.templateContent()),
-      new FileContentProvider(
-        { dir: this.directory, pattern: "*.pub" },
-        { destination: "/etc/ssh/", mode: 0o644 }
-      ),
-      new FileContentProvider(
-        { dir: this.directory, pattern: "*_key" },
-        { destination: "/etc/ssh/", mode: 0o600 }
-      ),
       new FileContentProvider({ dir, pattern: ["**/*", "**/.ssh/*"] })
     );
 
-    Object.assign(packageData.properties, {
-      description: `${this.typeName} definitions for ${this.fullName}`,
-      dependencies: [...this.depends],
-      provides: [...this.provides],
-      replaces: [...this.replaces],
-      depends: [...this.depends],
-      optional: [...this.optional],
-      backup: "root/.ssh/known_hosts"
-    });
-
     await loadHooks(
       packageData,
       new URL("host.install", import.meta.url).pathname
@@ -412,8 +338,6 @@ export class Host extends ServiceOwner {
         for (const { serviceName, configFileName, content } of asArray(
           service.expand(service.systemdConfigs(this.name))
         )) {
-          //console.log("SERVICE", service.fullName, configFileName);
-
           await writeLines(dir, configFileName, content);
 
           addHook(

package/src/module.mjs

@@ -1,4 +1,5 @@
 export * from "./type.mjs";
+export * from "./core.mjs";
 export * from "./base.mjs";
 export * from "./cluster.mjs";
 export * from "./owner.mjs";
@@ -8,6 +9,7 @@ export * from "./service-owner.mjs";
 export * from "./network.mjs";
 export * from "./network-address.mjs";
 export * from "./common-attributes.mjs";
+export * from "./content.mjs";
 export * from "./host.mjs";
 export * from "./network-interfaces/network-interface.mjs";
 export * from "./network-interfaces/loopback.mjs";

package/src/owner.mjs

@@ -163,15 +163,6 @@ export class Owner extends ServiceOwner {
     return this.subnets.values().find(subnet => subnet.matchesAddress(address));
   }
 
-  get derivedPackaging() {
-    let all = new Set();
-    for (const host of this.hosts.values()) {
-      all = all.union(host.packaging);
-    }
-
-    return all;
-  }
-
   *networkAddresses(filter) {
     for (const host of this.hosts.values()) {
       yield* host.networkAddresses(filter);

package/src/services/bind.mjs

@@ -825,17 +825,17 @@ export class bind extends CoreService {
   }
 
   async *preparePackages(dir) {
-    const permissions = this.packageContentPermissions;
+    const permissions = this.content.permissions;
     const packageData = this.packageData;
 
     packageData.sources = await Array.fromAsync(
-      this.templateContent(...permissions)
+      this.templateContent(permissions)
     );
 
     let hasContent = packageData.sources.length > 0;
 
     packageData.sources.push(
-      new FileContentProvider(dir + "/", ...permissions)
+      new FileContentProvider(dir + "/", permissions)
     );
 
     const outputControl = { packageData, dir, permissions };

package/src/services/mosquitto.mjs

@@ -58,7 +58,7 @@ export class mosquitto extends CoreService {
       wd.map(n => [n.fullName, n.directory])
     );*/
 
-    const permissions = this.packageContentPermissions;
+    const permissions = this.content.permissions;
     const packageData = this.packageData;
 
     packageData.sources = await Array.fromAsync(
@@ -66,7 +66,7 @@ export class mosquitto extends CoreService {
     );
 
     packageData.sources.push(
-      new FileContentProvider(dir + "/", ...permissions)
+      new FileContentProvider(dir + "/", permissions)
     );
 
     await writeLines(

package/src/subnet.mjs

@@ -5,16 +5,11 @@ import {
   matchPrefixIP,
   FAMILY_IPV6
 } from "ip-utilties";
-import {
-  string_attribute,
-  name_attribute,
-  integer_attribute,
-  getAttribute
-} from "pacc";
+import { string_attribute, name_attribute, integer_attribute } from "pacc";
 import { networks_attribute } from "./common-attributes.mjs";
-import { addType, Network } from "pmcf";
+import { addType, Network, Core } from "pmcf";
 
-export class Subnet {
+export class Subnet extends Core {
   static name = "subnet";
   static priority = 1;
   static owners = ["owner", "network", "network_interface", "root"];
@@ -34,6 +29,7 @@ export class Subnet {
   networks = new Set();
 
   constructor(owner, address) {
+    super();
     const { longPrefix, prefix, prefixLength, cidr, family } =
       normalizeCIDR(address);
 
@@ -44,27 +40,13 @@ export class Subnet {
     this.family = family;
   }
 
-  get owner() {
-    return this._owner;
-  }
-
   set owner(value) {
-    this._owner = value;
+    super.owner = value;
     if (value instanceof Network) {
       this.networks.add(value);
     }
   }
 
-  attribute(name) {
-    return getAttribute(this, name);
-  }
-
-  value(name) {
-    return this.attribute(name);
-  }
-
-  *_walkDirections(directions, seen) {}
-
   get cidr() {
     return this.address;
   }