pmcf 4.30.8 → 5.0.0

package/src/owner.mjs

@@ -1,199 +1,139 @@
 import { normalizeCIDR, familyIP, FAMILY_IPV4 } from "ip-utilties";
+import { FileContentProvider } from "npm-pkgbuild";
+import { AggregatedMap } from "aggregated-map";
 import {
-  default_attribute_writable,
   string_set_attribute_writable,
   string_attribute_writable,
-  boolean_attribute_writable,
   email_attribute
 } from "pacc";
-import { addType } from "pacc";
-import { asIterator, asArray, union } from "./utils.mjs";
+import { asArray, union } from "./utils.mjs";
 import { Base } from "./base.mjs";
 import { Subnet, SUBNET_GLOBAL_IPV4, SUBNET_GLOBAL_IPV6 } from "./subnet.mjs";
-import { networks_attribute } from "./network-support.mjs";
-import { Host } from "./host.mjs";
-
-const EMPTY = new Map();
+import {
+  networks_attribute,
+  owners_attribute,
+  hosts_attribute,
+  clusters_attribute,
+  subnets_attribute,
+  networkInterfaces_attribute
+} from "./common-attributes.mjs";
+import { addType, assign } from "pmcf";
+import { loadHooks } from "./hooks.mjs";
 
 export class Owner extends Base {
   static name = "owner";
   static priority = 2;
-  static owners = [Owner, "location", "root"];
+  static owners = [Owner, "root"];
   static attributes = {
     networks: networks_attribute,
-    hosts: {
-      ...default_attribute_writable,
-      type: Host,
-      collection: true
-    },
-    clusters: {
-      ...default_attribute_writable,
-      type: "cluster",
-      collection: true
-    },
-    subnets: {
-      ...default_attribute_writable,
-      type: Subnet,
-      collection: true
-    },
-    country: string_attribute_writable,
-    domain: string_attribute_writable,
-    domains: string_set_attribute_writable,
-    timezone: string_attribute_writable,
+    hosts: hosts_attribute,
+    clusters: clusters_attribute,
+    owners: owners_attribute,
+    subnets: subnets_attribute,
+    networkInterfaces: networkInterfaces_attribute,
+    country: { ...string_attribute_writable, name: "country" },
+    domain: { ...string_attribute_writable, name: "domain" },
+    domains: { ...string_set_attribute_writable, name: "domains" },
+    timezone: { ...string_attribute_writable, name: "timezone" },
     architectures: {
       ...string_set_attribute_writable,
+      name: "architectures",
       description: "all supported architectures"
     },
-    locales: { ...string_set_attribute_writable, description: "unix locale" },
-    administratorEmail: { ...email_attribute, writable: true },
-    template: { ...boolean_attribute_writable, private: true }
+    locales: {
+      ...string_set_attribute_writable,
+      name: "locales",
+      description: "unix locale"
+    },
+    administratorEmail: {
+      ...email_attribute,
+      name: "administratorEmail",
+      writable: true
+    }
   };
 
   static {
     addType(this);
   }
 
-  _membersByType = new Map();
-  _bridges = new Set();
-  _subnets = new Set();
+  owners = new Map();
+  networkInterfaces = new Map();
+  _networks = new Map();
+  _clusters = new Map();
+  _hosts = new Map();
+  _subnets = new Map();
 
   /**
-   * @return {boolean}
+   * hosts we own direcly.
    */
-  get isTemplate() {
-    return this.template ?? super.isTemplate;
+  get directHosts() {
+    return new AggregatedMap([this._hosts, this._clusters]);
   }
 
-  named(name) {
-    if (name[0] === "/") {
-      name = name.substring(this.fullName.length + 1);
-    }
-
-    for (const slot of this._membersByType.values()) {
-      const object = slot.get(name);
-      if (object) {
-        return object;
-      }
-    }
-
-    // TODO cascade
-    const parts = name.split(/\//);
-
-    if (parts.length >= 2) {
-      const last = parts.pop();
-
-      const next = this.named(parts.join("/"));
-      if (next) {
-        return next.named(last);
-      }
-    }
+  get hosts() {
+    return new AggregatedMap(
+      [this, ...this.networks.values(), ...this.owners.values()].map(
+        node => node.directHosts
+      )
+    );
   }
 
-  typeNamed(typeName, name) {
-    const typeSlot = this._membersByType.get(typeName);
-    if (typeSlot) {
-      const object = typeSlot.get(
-        name[0] === "/" ? name.substring(this.fullName.length + 1) : name
-      );
-      if (object) {
-        return object;
-      }
-    }
+  set hosts(value) {
+    this._hosts = value;
+  }
 
-    return super.typeNamed(typeName, name);
+  get clusters() {
+    return new AggregatedMap(
+      [this, ...this.networks.values(), ...this.owners.values()].map(
+        node => node._clusters
+      )
+    );
   }
 
-  typeList(typeName) {
-    const typeSlot = this._membersByType.get(typeName);
-    return (typeSlot || EMPTY).values();
+  set clusters(value) {
+    this._clusters = value;
   }
 
-  addTypeObject(typeName, name, object) {
-    const typeSlot = this._membersByType.getOrInsertComputed(
-      typeName,
-      () => new Map()
+  get networks() {
+    return new AggregatedMap(
+      [this, ...this.owners.values()].map(node => node._networks)
     );
-    typeSlot.set(name, object);
   }
 
-  addObject(object) {
-    if (object instanceof Subnet) {
-      this._subnets.add(object);
-    } else {
-      if (object.owner && object.owner !== this) {
-        this.addTypeObject(
-          object.typeName,
-          object.owner.name + "/" + object.name,
-          object
-        );
-
-        return;
-      }
-      this.addTypeObject(object.typeName, object.name, object);
-    }
+  set networks(value) {
+    this._networks = value;
   }
 
   get services() {
-    return [...this.hosts]
-      .map(host => Array.from(host.services.values()))
-      .flat();
-  }
-
-  get locations() {
-    return this.typeList("location");
+    return new AggregatedMap(
+      [...this.hosts.values()].map(host => host.services)
+    );
   }
 
-  hostNamed(name) {
-    return this.typeNamed("host", name) || this.typeNamed("cluster", name);
+  get network() {
+    return [...this.networks.values()][0] || super.network;
   }
 
-  directHosts() {
-    let hosts = new Set();
-    for (const type of ["host", "cluster"]) {
-      hosts = hosts.union(new Set(Array.from(this.typeList(type))));
-    }
-
-    return hosts;
+  get subnets() {
+    return this._subnets;
   }
 
-  set hosts(value) {
-    this.typeNamed("host").set(value.name, value);
+  set subnets(value) {
+    this.addSubnet(value);
   }
 
-  get hosts() {
-    let hosts = this.directHosts();
-
-    for (const type of Host.owners) {
-      for (const object of this.typeList(type)) {
-        hosts = hosts.union(object.hosts);
-      }
+  addSubnet(address) {
+    if (address instanceof Subnet) {
+      return assign(subnets_attribute, this, address);
     }
 
-    return hosts;
-  }
-
-  networkNamed(name) {
-    return this.typeNamed("network", name);
-  }
-
-  get networks() {
-    //return this._membersByType.get("network") || new Map();
-    return this.typeList("network");
-  }
-
-  subnetNamed(name) {
-    return this.subnets.values().find(s => s.name == name);
-  }
-
-  get subnets() {
-    return this.unionFromDirections(["this", "owner"], "_subnets");
-  }
-
-  addSubnet(address) {
     const { cidr, prefixLength } = normalizeCIDR(address);
 
     if (cidr && prefixLength !== 0) {
-      return this.subnetNamed(cidr) || new Subnet(this, cidr);
+      return (
+        this._subnets.get(cidr) ||
+        assign(subnets_attribute, this, new Subnet(cidr))
+      );
     }
 
     let subnet = this.subnetForAddress(address);
@@ -205,109 +145,26 @@ export class Owner extends Base {
           : SUBNET_GLOBAL_IPV6;
 
       this.error(
-        `Address without subnet ${address}`,
-        [...this.subnets].map(s => s.address)
+        `Address without subnet ${address} available (${[...this.subnets.keys()]})`
       );
     }
 
-    this._subnets.add(subnet);
+    this._subnets.set(subnet.name, subnet);
     return subnet;
   }
 
+  /**
+   *
+   * @param {string} address
+   * @returns {Subnet?}
+   */
   subnetForAddress(address) {
     return this.subnets.values().find(subnet => subnet.matchesAddress(address));
   }
 
-  get clusters() {
-    //return this._membersByType.get("cluster") || new Map();
-    return this.typeList("cluster");
-  }
-
-  get bridges() {
-    return this._bridges;
-  }
-
-  addBridge(network, destinationNetworks) {
-    if (destinationNetworks) {
-      let bridge;
-
-      for (bridge of this._bridges) {
-        if (bridge.has(network.name)) {
-          bridge.delete(network.name);
-          bridge.add(network);
-          break;
-        }
-
-        if (bridge.has(network)) {
-          break;
-        }
-      }
-
-      if (!bridge) {
-        bridge = new Set([network]);
-        this._bridges.add(bridge);
-      }
-
-      for (const nameOrNetwork of asIterator(destinationNetworks)) {
-        const other =
-          nameOrNetwork instanceof Owner
-            ? nameOrNetwork
-            : this.networkNamed(nameOrNetwork);
-        if (other) {
-          if (!bridge.has(other)) {
-            bridge.add(other);
-            other.bridge = bridge;
-          }
-        } else {
-          this.error("Unknown destination", nameOrNetwork);
-          //  bridge.add(nameOrNetwork);
-          //  this.finalize(() => this._resolveBridges());
-        }
-      }
-
-      return bridge;
-    }
-  }
-
-  /*
-  _resolveBridges() {
-    for (const bridge of this._bridges) {
-      const subnets = new Map();
-
-      for (let network of bridge) {
-        if (typeof network === "string") {
-          const other = this.networkNamed(network);
-
-          if (other) {
-            bridge.delete(network);
-            bridge.add(other);
-            other.bridge = bridge;
-            network = other;
-          } else {
-            this.error(`Unresolvabale bridge network`, network);
-          }
-        }
-        // enshure only one subnet address in the bridge
-        for (const subnet of network.subnets) {
-          const present = subnets.get(subnet.address);
-          if (present) {
-            subnet.owner.addObject(present);
-
-            for (const n of subnet.networks) {
-              present.networks.add(n);
-            }
-          } else {
-            subnets.set(subnet.address, subnet);
-          }
-        }
-      }
-    }
-  }
-*/
-
   get derivedPackaging() {
     let all = new Set();
-    for (const host of this.hosts) {
+    for (const host of this.hosts.values()) {
       all = all.union(host.packaging);
     }
 
@@ -315,7 +172,7 @@ export class Owner extends Base {
   }
 
   *networkAddresses(filter) {
-    for (const host of this.hosts) {
+    for (const host of this.hosts.hosts()) {
       yield* host.networkAddresses(filter);
     }
   }
@@ -381,7 +238,7 @@ export class Owner extends Base {
   get domains() {
     let domains = new Set();
 
-    for (const object of this.hosts) {
+    for (const object of this.hosts.values()) {
       domains = domains.union(object.domains);
     }
 
@@ -395,7 +252,7 @@ export class Owner extends Base {
   get domainNames() {
     let names = new Set();
 
-    for (const host of this.hosts) {
+    for (const host of this.hosts.values()) {
       names = names.union(new Set(host.domainNames));
     }
 
@@ -415,10 +272,37 @@ export class Owner extends Base {
 
     const architectures = new Set();
 
-    for (const host of this.hosts) {
+    for (const host of this.hosts.values()) {
       architectures.add(host.architecture);
     }
 
     return architectures;
   }
+
+  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;
+  }
 }

package/src/root.mjs

@@ -1,23 +1,29 @@
-import { addType } from "pmcf";
-import { Location } from "./location.mjs";
+import { Owner, addType } from "pmcf";
 
-export class root extends Location {
+export class root extends Owner {
   static priority = 3;
-  
   static {
     addType(this);
   }
 
-  constructor(directory) {
-    super(undefined, "");
+  constructor(directory="/") {
+    super();
     this.directory = directory;
-    this.addObject(this);
+    this.name = "";
   }
 
   get fullName() {
     return "";
   }
 
+  named(name) {
+    if (name === "" || name === "/") {
+      return this;
+    }
+
+    return super.named(name);
+  }
+
   get root() {
     return this;
   }

package/src/service-owner.mjs

@@ -1,5 +1,6 @@
-import { default_attribute_writable } from "pacc";
-import { Base, Service, addType } from "pmcf";
+import { default_collection_attribute_writable } from "pacc";
+import { Base, addType } from "pmcf";
+import { owner_attribute } from "./common-attributes.mjs";
 
 export class ServiceOwner extends Base {
   static name = "service-owner";
@@ -7,9 +8,10 @@ export class ServiceOwner extends Base {
   static owners = ["owner", "network", "root"];
   static attributes = {
     services: {
-      ...default_attribute_writable,
+      ...default_collection_attribute_writable,
+      name: "services",
       type: "service",
-      collection: true
+      backpointer: owner_attribute
     }
   };
 
@@ -27,14 +29,6 @@ export class ServiceOwner extends Base {
     return this._services;
   }
 
-  addObject(object) {
-    if (object instanceof Service) {
-      this._services.set(object.name, object);
-    } else {
-      super.addObject(object);
-    }
-  }
-
   materializeExtends() {
     super.materializeExtends();
 
@@ -46,23 +40,10 @@ export class ServiceOwner extends Base {
 
       if (present) {
         present.extends.add(service);
+        present.materializeExtends();
       } else {
         this.services = service.forOwner(this);
       }
     }
   }
-
-  typeNamed(typeName, name) {
-    if (typeName === "service") {
-      const service = this.services.get(name);
-      if (service) {
-        return service;
-      }
-    }
-
-    if (typeName === "number") {
-      throw new Error("invalidType", { cause: typeName });
-    }
-    return super.typeNamed(typeName, name);
-  }
 }

package/src/service.mjs

@@ -3,8 +3,11 @@ import {
   string_attribute_writable,
   number_attribute_writable,
   string_set_attribute,
-  default_attribute_writable,
-  boolean_attribute_false
+  default_collection_attribute_writable,
+  boolean_attribute_false,
+  port_attribute_writable,
+  type_attribute_writable,
+  priority_attribute
 } from "pacc";
 import {
   Base,
@@ -16,7 +19,7 @@ import {
   addType
 } from "pmcf";
 import { asArray } from "./utils.mjs";
-import { networkAddressAttributes } from "./network-support.mjs";
+import { networkAddressAttributes } from "./common-attributes.mjs";
 import {
   serviceTypeEndpoints,
   serviceTypes,
@@ -31,20 +34,22 @@ import {
 } from "./dns-utils.mjs";
 
 export const endpointAttributes = {
-  port: number_attribute_writable,
+  port: port_attribute_writable,
   protocol: {
     ...string_attribute_writable,
-    values: ["tcp", "udp", "quic"]
+    name: "protocol",
+    values: new Set(["tcp", "udp", "quic"])
   },
-  type: string_attribute_writable,
-  types: string_set_attribute,
-  tls: boolean_attribute_false
+  type: type_attribute_writable,
+  types: { ...string_set_attribute, name: "types" },
+  tls: { ...boolean_attribute_false, name: "tls" }
 };
 
 export class Service extends Base {
   static name = "service";
   static priority = 1.1;
   static owners = [Host, "cluster", "network_interface"];
+  static specializationOf = Service;
   static specializations = {};
   static factoryFor(owner, value) {
     const type = value.type ?? value.name;
@@ -61,14 +66,14 @@ export class Service extends Base {
     ...networkAddressAttributes,
     ...endpointAttributes,
     extends: {
-      ...default_attribute_writable,
-      type: Service,
-      collection: true,
-      owner: false
+      ...default_collection_attribute_writable,
+      name: "extends",
+      type: Service
     },
-    alias: string_attribute_writable,
-    weight: { ...number_attribute_writable /*default: 1*/ },
-    systemdService: string_attribute_writable
+    alias: { ...string_attribute_writable, name: "alias" },
+    priority: priority_attribute,
+    weight: { ...number_attribute_writable, name: "weight" /*default: 1*/ },
+    systemdService: { ...string_attribute_writable, name: "systemdService" }
   };
 
   static {
@@ -100,7 +105,7 @@ export class Service extends Base {
   }
 
   get domainName() {
-    return this.host.domainName;
+    return this.host?.domainName;
   }
 
   get networks() {
@@ -220,6 +225,14 @@ export class Service extends Base {
     );
   }
 
+  set priority(value) {
+    this._priority = value;
+  }
+
+  get priority() {
+    return this.attribute("_priority") ?? this.owner?.priority ?? 1;
+  }
+
   set weight(value) {
     this._weight = value;
   }
@@ -249,10 +262,10 @@ export class Service extends Base {
 
   get packageData() {
     const packageData = super.packageData;
-    const location = `${this.location.name}-${this.host.name}`;
-    packageData.properties.name = `${this.type}-${location}`;
+    const name = `${this.owner.name}-${this.host.name}`;
+    packageData.properties.name = `${this.type}-${name}`;
     packageData.properties.description = `${this.type} service definitions for ${this.fullName}`;
-    packageData.properties.groups.push("service-config", location);
+    packageData.properties.groups.push("service-config", name);
     return packageData;
   }