pmcf 6.37.2 → 6.38.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pmcf",
-  "version": "6.37.2",
+  "version": "6.38.0",
   "publishConfig": {
     "access": "public"
   },
@@ -53,7 +53,7 @@
     "aggregated-map": "^1.0.10",
     "content-entry-transform": "^1.7.3",
     "ip-utilties": "^3.13.0",
-    "npm-pkgbuild": "^20.9.5",
+    "npm-pkgbuild": "^21.0.0",
     "pacc": "^11.6.0",
     "package-directory": "^8.2.0",
     "yaml": "^2.9.0"

package/src/base.mjs

@@ -1,20 +1,14 @@
 import { join } from "node:path";
 import { stat } from "node:fs/promises";
-import { AggregatedMap } from "aggregated-map";
-import { allOutputs } from "npm-pkgbuild";
 import {
   createExpressionTransformer,
   transform
 } from "content-entry-transform";
 import { FileContentProvider } from "npm-pkgbuild";
 import {
-  getAttribute,
   parse,
   globals,
-  expand,
   extract,
-  toExternal,
-  filterPublic,
   extendingAttributeIterator,
   name_attribute_writable,
   type_attribute_writable,
@@ -22,10 +16,10 @@ import {
   string_set_attribute_writable,
   description_attribute_writable,
   boolean_attribute_writable,
-  object_attribute
+  default_attribute_writable
 } from "pacc";
 import { union } from "./utils.mjs";
-import { addType } from "pmcf";
+import { addType, Core } from "pmcf";
 import { owner_attribute, aliases_attribute } from "./common-attributes.mjs";
 
 /**
@@ -33,7 +27,7 @@ import { owner_attribute, aliases_attribute } from "./common-attributes.mjs";
  * attributes: as declared in the types
  * properties: use defined values to support attribute value definitions
  */
-export class Base {
+export class Base extends Core {
   static name = "base";
   static key = "name";
   static priority = 0;
@@ -52,8 +46,7 @@ export class Base {
       private: true
     },
 
-    packaging: { ...string_set_attribute_writable, name: "packaging" },
- //   packageContentProperties: { ...object_attribute, writable: true, name: "packageContentProperties"}
+    content: { ...default_attribute_writable, type: "content", name: "content" }
   };
 
   static {
@@ -67,94 +60,22 @@ export class Base {
   description;
   name;
   properties = {};
-  extends = new Set();
   _aliases = new Set();
   _tags = new Set();
-  _packaging = new Set();
   _directory;
 
-  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;
+  value(name) {
+    return this.attribute(name) ?? this.property(name) ?? this.named(name);
   }
 
   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;
-            }
-          }
+    super.materializeExtends();
+    if (this.content) {
+      for (const e of this.extends) {
+        if (e.content) {
+          this.content.extends.add(e.content);
         }
-
-        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);
-            }
-          }
-        }
-      }*/
     }
   }
 
@@ -180,184 +101,6 @@ export class Base {
     }
   }
 
-  /**
-   * 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 Base) {
-                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;
-  }
-
-  /**
-   * Walk the object graph in some directions and deliver seen nodes.
-   * @param {string[]} directions
-   * @return {Iterable<Base>}
-   */
-  *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);
-          }
-        }
-      }
-    }
-  }
-
-  get typeName() {
-    return this.constructor.name;
-  }
-
-  /**
-   *
-   * @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);
-      }
-    }
-  }
-
-  /**
-   * 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) ?? this.property(name) ?? this.named(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);
-      }
-    }
-  }
-
   get root() {
     return this.owner?.root;
   }
@@ -442,22 +185,6 @@ export class Base {
     return this.expression("services[types[smtp]][0]");
   }
 
-  /**
-   *
-   * @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 services() {
     return this.owner?.services || new Map();
   }
@@ -479,28 +206,6 @@ export class Base {
     return this.owner ? join(this.owner.fullName, "/", this.name) : this.name;
   }
 
-  get derivedPackaging() {
-    return this.owner?.packaging;
-  }
-
-  set packaging(value) {
-    this._packaging = union(value, this._packaging);
-  }
-
-  get packaging() {
-    const dp = this.derivedPackaging;
-
-    if (dp) {
-      return this._packaging.union(dp);
-    }
-
-    return this._packaging;
-  }
-
-  get outputs() {
-    return new Set(allOutputs.filter(o => this.packaging.has(o.name)));
-  }
-
   get systemUserName() {
     return this.constructor.name;
   }
@@ -509,36 +214,16 @@ export class Base {
     return this.constructor.name;
   }
 
-  get packageContentPermissions() {
-    const owner = this.systemUserName;
-    const group = this.systemGroupName;
-    return [
-      {
-        mode: 0o644,
-        owner,
-        group
-      },
-      {
-        mode: 0o755,
-        owner,
-        group
-      }
-    ];
-  }
-
   get packageData() {
-    const nameParts = [this.typeName, this.owner?.name, this.name];
-    return {
-      sources: [],
-      outputs: this.outputs,
-      properties: {
-        name: nameParts.filter(n => n !== undefined && n.length > 0).join("-"),
-        description: `${this.type} definitions for ${this.fullName}`,
-        access: "private",
-        dependencies: this.depends,
-        groups: [this.typeName]
+    if (!this.content) {
+      for (const e of this.walkDirections(["extends"])) {
+        if (e.content) {
+          this.content = e.content.forOwner(this);
+          break;
+        }
       }
-    };
+    }
+    return this.content?.packageData(this);
   }
 
   async *preparePackages(stagingDir) {}
@@ -600,32 +285,12 @@ export class Base {
    * @return {boolean}
    */
   get isTemplate() {
-    //console.log("T", this.name, this.owner?.name, this.owner?.owner?.name);
     return (
       this.template ??
       (this.name?.indexOf("*") >= 0 || this.owner?.isTemplate || false)
     );
   }
 
-  /**
-   *
-   * @param {any} object
-   * @returns {any}
-   */
-  expand(object) {
-    if (this.isTemplate || object instanceof Base) {
-      return object;
-    }
-
-    return expand(object, {
-      stopClass: Base,
-      root: this.root,
-      current: this,
-      valueFor: (name, at) =>
-        typeof at?.value === "function" ? at.value(name) : globals[name]
-    });
-  }
-
   error(...args) {
     console.error(`${this.toString()}:`, ...args);
   }

package/src/content.mjs

@@ -3,18 +3,29 @@ import {
   string_set_attribute_writable,
   default_collection_attribute_writable
 } from "pacc";
-import { Base, addType } from "pmcf";
+import { allOutputs } from "npm-pkgbuild";
+import { Core, addType } from "pmcf";
+import { union } from "./utils.mjs";
 
-export class permission extends Base {
+export class permission extends Core {
+  static priority = 1.9;
   static attributes = {
     pattern: { ...string_attribute_writable, key: true, name: "pattern" },
     user: { ...string_attribute_writable, name: "user" },
     group: { ...string_attribute_writable, name: "group" },
     mode: { ...string_attribute_writable, name: "mode" }
   };
+
+  static {
+    addType(this);
+  }
+
+  get name() {
+    return this.pattern;
+  }
 }
 
-export class content extends Base {
+export class content extends Core {
   static priority = 1.9;
   static attributes = {
     permissions: {
@@ -22,21 +33,75 @@ export class content extends Base {
       type: permission,
       name: "permissions"
     },
+    access: {
+      ...string_attribute_writable,
+      name: "access",
+      default: "private"
+    },
     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" }
+    optional: { ...string_set_attribute_writable, name: "optional" },
+    groups: { ...string_set_attribute_writable, name: "groups" },
+    backup: { ...string_set_attribute_writable, name: "backup" },
+    packaging: { ...string_set_attribute_writable, name: "packaging" }
   };
 
   static {
     addType(this);
   }
 
-  permissions = new Map();
+  _permissions = new Map();
   _provides = new Set();
   _replaces = new Set();
   _depends = new Set();
   _optional = new Set();
+  _packaging = new Set();
+  _groups = new Set();
+
+  get name() {
+    return "content";
+  }
+
+  value(name) {
+  //  console.log("CONTENT VALUE", this.name, this.owner.fullName, name, this.owner.name);
+    return this.owner.value(name) ?? super.value(name);
+  }
+
+  /**
+   * @return {string}
+   */
+  get access() {
+    return this.attribute("_access");
+  }
+
+  set access(value) {
+    this._access = value;
+  }
+
+  set packaging(value) {
+    this._packaging = union(value, this._packaging);
+  }
+
+  get packaging() {
+    const dp = this.derivedPackaging;
+
+    if (dp) {
+      return this._packaging.union(dp);
+    }
+
+    return this._packaging;
+  }
+
+  get outputs() {
+    return new Set(allOutputs.filter(o => this.packaging.has(o.name)));
+  }
+
+  get derivedPackaging() {
+    return this.expand(
+      this.unionFromDirections(["this", "extends"], "_packaging")
+    );
+  }
 
   set provides(value) {
     this._provides = union(value, this._provides);
@@ -77,4 +142,67 @@ export class content extends Base {
       this.unionFromDirections(["this", "extends"], "_optional")
     );
   }
+
+  set groups(value) {
+    this._groups = union(value, this._groups);
+  }
+
+  get groups() {
+    return this.expand(
+      this.unionFromDirections(["this", "extends"], "_groups")
+    );
+  }
+
+  set backup(value) {
+    this._backup = union(value, this._backup);
+  }
+
+  get backup() {
+    return this.expand(
+      this.unionFromDirections(["this", "extends"], "_backup")
+    );
+  }
+
+  get permissions() {
+    const p = this.mapFromDirections(["this", "extends"], "_permissions");
+
+    return p;
+
+    /*
+    const owner = this.systemUserName;
+    const group = this.systemGroupName;
+    return [
+      {
+        mode: 0o644,
+        owner,
+        group
+      },
+      {
+        mode: 0o755,
+        owner,
+        group
+      }
+    ];
+*/
+  }
+
+  packageData(node) {
+    const nameParts = [node.typeName, node.owner?.name, node.name];
+
+    return {
+      sources: [],
+      outputs: this.outputs,
+      properties: {
+        name: nameParts.filter(n => n !== undefined && n.length > 0).join("-"),
+        description: `${node.type} definitions for ${node.fullName}`,
+        access: this.access,
+        groups: [node.typeName, ...this.groups],
+        depends: [...this.depends],
+        provides: [...this.provides],
+        replaces: [...this.replaces],
+        optional: [...this.optional],
+        backup: [...this.backup]
+      }
+    };
+  }
 }

package/src/core-service.mjs

@@ -282,8 +282,9 @@ export class CoreService extends Base {
     const pd = this.packageData;
 
     pd.sources = await Array.fromAsync(
-      this.templateContent(...this.packageContentPermissions)
+      this.templateContent(this.content.permissions)
     );
+
     if (pd.sources.length) {
       yield pd;
     }

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/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;
   }