pmcf 1.46.4 → 1.47.1

package/src/host.mjs

@@ -1,6 +1,5 @@
 import { Base } from "./base.mjs";
-import { Network } from "./network.mjs";
-import { Service } from "./service.mjs";
+import { networkProperties } from "./network-support.mjs";
 import {
   asArray,
   isIPv4Address,
@@ -11,8 +10,41 @@ import {
 } from "./utils.mjs";
 import { addType } from "./types.mjs";
 
+const HostTypeDefinition = {
+  name: "host",
+  priority: 0.5,
+  owners: ["owner", "network", "root"],
+  extends: Base.typeDefinition,
+  properties: {
+    networkInterfaces: {
+      type: "network_interface",
+      collection: true,
+      writeable: true
+    },
+    services: { type: "service", collection: true, writeable: true },
+    os: { type: "string", collection: false, writeable: true },
+    distribution: { type: "string", collection: false, writeable: true },
+    deployment: { type: "string", collection: false, writeable: true },
+    master: { type: "boolean", collection: false, writeable: true },
+    model: { type: "string", collection: false, writeable: false },
+    serial: { type: "string", collection: false, writeable: true },
+    vendor: { type: "string", collection: false, writeable: true },
+    chassis: { type: "string", collection: false, writeable: true },
+    isModel: { type: "boolean", collection: false, writeable: false },
+    priority: { type: "number", collection: false, writeable: true },
+    replaces: { type: "string", collection: true, writeable: true },
+    depends: { type: "string", collection: true, writeable: true },
+    provides: { type: "string", collection: true, writeable: true },
+    extends: { type: "host", collection: true, writeable: true },
+    cidrAddresses: { type: "string", collection: true, writeable: false },
+    rawAddresses: { type: "string", collection: true, writeable: false },
+    rawAddress: { type: "string", collection: false, writeable: false }
+  }
+};
+
 export class Host extends Base {
   postinstall = [];
+  serial;
   #services = [];
   #extends = [];
   #networkInterfaces = new Map();
@@ -31,91 +63,29 @@ export class Host extends Base {
   }
 
   static get typeDefinition() {
-    return {
-      name: "host",
-      extends: Base,
-      properties: {
-        networkInterfaces: { type: "network_interface", collection: true },
-        services: { type: Service, collection: true },
-        os: { type: "string" },
-        distribution: { type: "string" },
-        deployment: { type: "string" },
-        master: { type: "boolean" },
-        model: { type: "string" },
-        replaces: { type: "string" },
-        depends: { type: "string" },
-        cidrAddresses: { type: "string", collection: true, writeable: false },
-        rawAddresses: { type: "string", collection: true, writeable: false },
-        rawAddress: { type: "string", writeable: false }
-      }
-    };
-  }
-
-  static async prepareData(root, data) {
-    if (data.extends) {
-      data.extends = await Promise.all(
-        asArray(data.extends).map(e => root.load(e, { type: Host }))
-      );
-    }
-
-    return this;
+    return HostTypeDefinition;
   }
 
   constructor(owner, data) {
     super(owner, data);
 
-    if (data.deployment !== undefined) {
-      this.#deployment = data.deployment;
-      delete data.deployment;
-    }
-    if (data.chassis !== undefined) {
-      this.#chassis = data.chassis;
-      delete data.chassis;
-    }
-    if (data.vendor !== undefined) {
-      this.#vendor = data.vendor;
-      delete data.vendor;
-    }
-    if (data.extends !== undefined) {
-      this.#extends = data.extends;
-      delete data.extends;
-    }
-    if (data.os !== undefined) {
-      this.#os = data.os;
-      delete data.os;
-    }
-    if (data.distribution !== undefined) {
-      this.#distribution = data.distribution;
-      delete data.distribution;
-    }
-    if (data.master !== undefined) {
-      this.#master = data.master;
-      delete data.master;
-    }
-    if (data.depends !== undefined) {
-      this.#depends = new Set(asArray(data.depends));
-      delete data.depends;
-    }
-    if (data.replaces !== undefined) {
-      this.#replaces = new Set(asArray(data.replaces));
-      delete data.replaces;
-    }
-    if (data.provides !== undefined) {
-      this.#provides = new Set(asArray(data.provides));
-      delete data.provides;
-    }
-
-    for (const host of this.extends) {
-      for (const service of host.services()) {
-        service.forOwner(this);
-      }
-    }
-
-    this.read(data);
-
-    Object.assign(this, data);
+    this.read(data, HostTypeDefinition);
 
     owner.addObject(this);
+
+    if (data.extends) {
+      this.finalize(() => {
+        for (const host of this.extends) {
+          this.depends = host.depends;
+          this.provides = host.provides;
+          this.replaces = host.replaces;
+
+          for (const service of host.findServices()) {
+            this.services = service.forOwner(this);
+          }
+        }
+      });
+    }
   }
 
   _traverse(...args) {
@@ -123,7 +93,7 @@ export class Host extends Base {
       for (const ni of this.networkInterfaces.values()) {
         ni._traverse(...args);
       }
-      for (const service of this.services()) {
+      for (const service of this.findServices()) {
         service._traverse(...args);
       }
 
@@ -132,14 +102,26 @@ export class Host extends Base {
     return false;
   }
 
+  set deployment(value) {
+    this.#deployment = value;
+  }
+
   get deployment() {
     return this.#deployment || this.extends.find(e => e.deployment)?.deployment;
   }
 
+  set chassis(value) {
+    this.#chassis = value;
+  }
+
   get chassis() {
     return this.#chassis || this.extends.find(e => e.chassis)?.chassis;
   }
 
+  set vendor(value) {
+    this.#vendor = value;
+  }
+
   get vendor() {
     return this.#vendor || this.extends.find(e => e.vendor)?.vendor;
   }
@@ -152,40 +134,70 @@ export class Host extends Base {
     return this.extends.find(h => h.isModel);
   }
 
+  set extends(value) {
+    this.#extends.push(value);
+  }
+
   get extends() {
-    return this.#extends.map(e => this.expand(e));
+    return this.#extends;
+  }
+
+  set provides(value) {
+    if (value instanceof Set) {
+      this.#provides = this.#provides.union(value);
+    } else {
+      this.#provides.add(value);
+    }
   }
 
   get provides() {
-    let provides = new Set(this.#provides);
-    this.extends.forEach(h => (provides = provides.union(h.provides)));
-    return provides;
+    return this.#provides;
+  }
+
+  set replaces(value) {
+    if (value instanceof Set) {
+      this.#replaces = this.#replaces.union(value);
+    } else {
+      this.#replaces.add(value);
+    }
   }
 
   get replaces() {
-    let replaces = new Set(this.#replaces);
-    this.extends.forEach(h => (replaces = replaces.union(h.replaces)));
-    return replaces;
+    return this.#replaces;
   }
 
-  get _depends() {
-    let depends = this.#depends;
-    this.extends.forEach(h => (depends = depends.union(h._depends)));
-    return depends;
+  set depends(value) {
+    if (value instanceof Set) {
+      this.#depends = this.#depends.union(value);
+    } else {
+      this.#depends.add(value);
+    }
   }
 
   get depends() {
-    return this.expand(this._depends);
+    return this.#depends;
+  }
+
+  set master(value) {
+    this.#master = value;
   }
 
   get master() {
     return this.#master || this.extends.find(e => e.master) ? true : false;
   }
 
+  set os(value) {
+    this.#os = value;
+  }
+
   get os() {
     return this.#os || this.extends.find(e => e.os);
   }
 
+  set distribution(value) {
+    this.#distribution = value;
+  }
+
   get distribution() {
     return this.#distribution || this.extends.find(e => e.distribution);
   }
@@ -213,15 +225,15 @@ export class Host extends Base {
     return this;
   }
 
-  get network() {
-    return this.owner.network;
+  get services() {
+    return this.#services;
   }
 
-  addService(service) {
-    this.#services.push(service);
+  set services(services) {
+    this.#services.push(services);
   }
 
-  *services(filter) {
+  *findServices(filter) {
     for (const service of this.#services) {
       if (
         !filter ||
@@ -234,20 +246,24 @@ export class Host extends Base {
     }
   }
 
-  get networkInterfaces() {
-    return this.#networkInterfaces;
+  typeNamed(typeName, name) {
+    if (typeName === NetworkInterfaceTypeDefinition.name) {
+      const ni = this.#networkInterfaces.get(name);
+      if (ni) {
+        return ni;
+      }
+    }
+
+    return super.typeNamed(typeName, name);
   }
 
-  networkInterfaceNamed(name) {
-    return this.#networkInterfaces.get(name);
+  get networkInterfaces() {
+    return this.#networkInterfaces;
   }
 
-  addNetworkInterface(networkInterface) {
+  set networkInterfaces(networkInterface) {
     this.#networkInterfaces.set(networkInterface.name, networkInterface);
-
-    if (networkInterface.network) {
-      networkInterface.network.addObject(this);
-    }
+    networkInterface.network?.addObject(this);
   }
 
   *networkAddresses() {
@@ -279,45 +295,32 @@ export class Host extends Base {
   async publicKey(type = "ed25519") {
     return readFile(join(this.directory, `ssh_host_${type}_key.pub`), "utf8");
   }
-
-  toJSON() {
-    return {
-      ...super.toJSON(),
-      extends: this.extends.map(host => host.name),
-      networkInterfaces: Object.fromEntries(
-        [...this.networkInterfaces.values()].map(ni => [ni.name, ni.toJSON()])
-      ),
-      services: Object.fromEntries(
-        [...this.services()].map(s => [s.name, s.toJSON()])
-      )
-    };
-  }
 }
 
+const NetworkInterfaceTypeDefinition = {
+  name: "network_interface",
+  priority: 0.4,
+  owners: ["host"],
+  extends: Base.typeDefinition,
+  properties: {
+    ...networkProperties,
+    hwaddr: { type: "string", collection: false, writeable: true },
+    ipAddresses: { type: "string", collection: true, writeable: true },
+    cidrAddresses: { type: "string", collection: true, writeable: false },
+    rawAddresses: { type: "string", collection: true, writeable: false },
+    network: { type: "network", collection: false, writeable: true },
+    destination: { type: "string", collection: false, writeable: true },
+    arpbridge: { type: "network_interface", collection: true, writeable: true }
+  }
+};
+
 export class NetworkInterface extends Base {
   static {
     addType(this);
   }
 
   static get typeDefinition() {
-    return {
-      name: "network_interface",
-      extends: Base,
-      properties: {
-        hwaddr: { type: "string" },
-        scope: { type: "string" },
-        kind: { type: "string" },
-        ssid: { type: "string" },
-        psk: { type: "string" },
-        metric: { type: "number" },
-        MTU: { type: "number" },
-        cidrAddresses: { type: "string", collection: true, writeable: false },
-        rawAddresses: { type: "string", collection: true, writeable: false },
-        network: { type: "network" },
-        gateway: {},
-        arpbridge: {}
-      }
-    };
+    return NetworkInterfaceTypeDefinition;
   }
 
   #ipAddresses = new Map();
@@ -332,48 +335,7 @@ export class NetworkInterface extends Base {
 
   constructor(owner, data) {
     super(owner, data);
-
-    if (data.ssid) {
-      this.#ssid = data.ssid;
-      delete data.ssid;
-    }
-    if (data.psk) {
-      this.#psk = data.psk;
-      delete data.psk;
-    }
-    if (data.scope) {
-      this.#psk = data.scope;
-      delete data.scope;
-    }
-    if (data.metric) {
-      this.#metric = data.metric;
-      delete data.metric;
-    }
-    if (data.kind) {
-      this.#kind = data.kind;
-      delete data.kind;
-    }
-
-    if (data.network) {
-      let network = owner.owner.networkNamed(data.network);
-
-      if (network) {
-        this.network = network;
-      } else {
-        network = data.network;
-        this.finalize(() => (this.network = network));
-      }
-
-      delete data.network;
-    } else if (owner.owner instanceof Network) {
-      this.network = owner.owner;
-    }
-
-    Object.assign(this, data);
-
-    owner.addNetworkInterface(this);
-
-    //this.arpbridge = owner.addARPBridge(this, data.arpbridge);
+    this.read(data, NetworkInterfaceTypeDefinition);
   }
 
   addSubnet(address) {
@@ -400,7 +362,7 @@ export class NetworkInterface extends Base {
   }
 
   get rawAddresses() {
-    return [...this.#ipAddresses].map(([address, subnet]) => address);
+    return [...this.#ipAddresses].map(([address]) => address);
   }
 
   get cidrAddresses() {
@@ -411,14 +373,14 @@ export class NetworkInterface extends Base {
 
   get rawIPv4Addresses() {
     return [...this.ipAddresses]
-      .filter(([address, subnet]) => isIPv4Address(address))
-      .map(([address, subnet]) => address);
+      .filter(([address]) => isIPv4Address(address))
+      .map(([address]) => address);
   }
 
   get rawIPv6Addresses() {
     return [...this.ipAddresses]
-      .filter(([address, subnet]) => isIPv6Address(address))
-      .map(([address, subnet]) => address);
+      .filter(([address]) => isIPv6Address(address))
+      .map(([address]) => address);
   }
 
   subnetForAddress(address) {
@@ -444,41 +406,54 @@ export class NetworkInterface extends Base {
     return this.owner;
   }
 
+  get network_interface() {
+    return this;
+  }
+
   get network() {
     return this.#network || this.host.network;
   }
 
-  set network(networkOrName) {
-    if (!(networkOrName instanceof Network)) {
-      let network = this.host.owner.networkNamed(networkOrName);
-
-      if (network) {
-        this.#network = network;
-        return;
-      } else {
-        this.error("Unknown network", networkOrName);
-      }
-    }
+  set network(network) {
+    this.#network = network;
+  }
 
-    this.#network = networkOrName;
+  set scope(value) {
+    this.#scope = value;
   }
 
   get scope() {
     return this.#scope || this.network?.scope || "global";
   }
 
+  set metric(value) {
+    this.#metric = value;
+  }
+
   get metric() {
     return this.#metric || this.network?.metric || 1004;
   }
 
+  set ssid(value) {
+    this.#ssid = value;
+  }
+
   get ssid() {
     return this.#ssid || this.network?.ssid;
   }
 
+  set psk(value) {
+    this.#psk = value;
+  }
+
   get psk() {
     return this.#psk || this.network?.psk;
   }
 
+  set kind(value) {
+    this.#kind = value;
+  }
+
   get kind() {
     return this.#kind || this.network?.kind;
   }

package/src/location.mjs

@@ -1,38 +1,38 @@
 import { Owner } from "./owner.mjs";
-import { Network } from "./network.mjs";
-import { Subnet } from "./subnet.mjs";
-import { Host } from "./host.mjs";
-import { DNSService } from "./dns.mjs";
-import { Cluster } from "./cluster.mjs";
 import { addType } from "./types.mjs";
 
+const LocationTypeDefinition = {
+  name: "location",
+  owners: [Owner.typeDefinition, "location", "root"],
+  priority: 1.0,
+  extends: Owner.typeDefinition,
+  properties: {
+    country: { type: "string", writeable: true },
+    locales: { type: "string", collection: true, writeable: true }
+  }
+};
+
 export class Location extends Owner {
   static {
     addType(this);
   }
 
   static get typeDefinition() {
-    return {
-      name: "location",
-      extends: Owner,
-      properties: {
-        networks: { type: Network, collection: true },
-        hosts: { type: Host, collection: true },
-        clusters: { type: Cluster, collection: true },
-        subnets: { type: Subnet, collection: true },
-        dns: { type: DNSService },
-        country: { type: "string" },
-        locales: { type: "string", collection: true }
-      }
-    };
+    return LocationTypeDefinition;
+  }
+
+  constructor(owner, data) {
+    super(owner, data);
+    this.read(data, LocationTypeDefinition);
   }
 
   get location() {
     return this;
   }
 
+
   locationNamed(name) {
-    if (this.fullName === name) {
+    if (this.isNamed(name)) {
       return this;
     }
 

package/src/network-support.mjs

@@ -0,0 +1,9 @@
+export const networkProperties = {
+  scope: { type: "string", collection: false, writeable: true },
+  kind: { type: "string", collection: false, writeable: true },
+  ssid: { type: "string", collection: false, writeable: true },
+  psk: { type: "string", collection: false, writeable: true },
+  metric: { type: "number", collection: false, writeable: true },
+  MTU: { type: "number", collection: false, writeable: true },
+  gateway: { type: "host", collection: false, writeable: true }
+};

package/src/network.mjs

@@ -1,8 +1,19 @@
 import { Owner } from "./owner.mjs";
 import { Subnet } from "./subnet.mjs";
-import { Host } from "./host.mjs";
-import { DNSService } from "./dns.mjs";
 import { addType } from "./types.mjs";
+import { networkProperties } from "./network-support.mjs";
+
+const NetworkTypeDefinition = {
+  name: "network",
+  owners: ["location", "cluster", "owner", "root"],
+  priority: 0.8,
+  extends: Owner.typeDefinition,
+  properties: {
+    ...networkProperties,
+    bridge: { type: "network", collection: true, writeable: true },
+    gateway: { type: "host", collection: false, writeable: true }
+  }
+};
 
 export class Network extends Owner {
   kind;
@@ -16,39 +27,12 @@ export class Network extends Owner {
   }
 
   static get typeDefinition() {
-    return {
-      name: "network",
-      extends: Owner,
-      properties: {
-        networks: { type: "network", collection: true },
-        hosts: { type: Host, collection: true },
-        clusters: { type: "cluster", collection: true },
-        subnets: { type: Subnet, collection: true },
-        dns: { type: DNSService, collection: false }
-        //metric: { type: "number" }
-        /*kind: { type: "string" },
-        scope: { type: "string" },
-        /*bridge: {},
-        gateway: {}*/
-      }
-    };
+    return NetworkTypeDefinition;
   }
 
   constructor(owner, data) {
     super(owner, data);
-
-    if (data.bridge) {
-      this.bridge = owner.addBridge(this, data.bridge);
-      delete data.bridge;
-    }
-
-    //this.read(data);
-
-    Object.assign(this, data);
-
-    if (typeof this.gateway === "string") {
-      this.finalize(() => (this.gateway = this.owner.hostNamed(this.gateway)));
-    }
+    this.read(data, NetworkTypeDefinition);
   }
 
   get network() {
@@ -56,7 +40,7 @@ export class Network extends Owner {
   }
 
   networkNamed(name) {
-    if (this.fullName === name) {
+    if (this.isNamed(name)) {
       return this;
     }
     return super.networkNamed(name);
@@ -73,7 +57,8 @@ export class Network extends Owner {
     return this.#bridge;
   }
 
-  set bridge(bridge) {
-    this.#bridge = bridge;
+  set bridge(network) {
+    this.#bridge = this.owner.addBridge(this, network);
+    network.bridge = this.bridge; // TODO should happen in addBridge
   }
 }