pmcf 1.5.2 → 1.6.0

package/bin/pmcf-named-defs

@@ -74,7 +74,7 @@ async function generateNamedDefs(location, targetDir) {
     };
     zones.push(zone);
 
-    for await (const subnet of location.subnets()) {
+    for (const subnet of location.subnets()) {
       if (subnet.address) {
         const reverse = reverseAddress(subnet.address);
         const reverseArpa = reverseArpaAddress(subnet.address);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pmcf",
-  "version": "1.5.2",
+  "version": "1.6.0",
   "publishConfig": {
     "access": "public"
   },

package/src/model.mjs

@@ -101,7 +101,7 @@ export class Base {
   }
 
   toString() {
-    return this.typeName + ":" + this.owner.name + "/" + this.name;
+    return this.typeName + ":" + (this.owner?.name || "") + "/" + this.name;
   }
 
   get propertyNames() {
@@ -113,22 +113,69 @@ export class Base {
   }
 }
 
-export class World {
+export class Owner extends Base {
+  #hosts = new Map();
+  #networks = new Map();
+  #subnets = new Map();
+
+  async *hosts() {
+    for (const host of this.#hosts.values()) {
+      yield host;
+    }
+  }
+
+  addHost(host) {
+    this.#hosts.set(host.name, host);
+  }
+
+  network(name) {
+    return this.#networks.get(name);
+  }
+
+  async *networks() {
+    for (const network of this.#networks.values()) {
+      yield network;
+    }
+  }
+
+  addNetwork(network) {
+    this.#networks.set(network.name, network);
+  }
+
+  addSubnet(subnet) {
+    this.#subnets.set(subnet.name, subnet);
+  }
+
+  subnet(name) {
+    return this.#subnets.get(name);
+  }
+
+  subnets() {
+    return this.#subnets.values();
+  }
+
+  toJSON() {
+    return {
+      ...super.toJSON(),
+      networks: [...this.#networks.keys()].sort(),
+      subnets: [...this.#subnets.keys()].sort(),
+      hosts: [...this.#hosts.keys()].sort()
+    };
+  }
+}
+
+export class World extends Owner {
   static get types() {
     return _types;
   }
 
-  directory;
   #byName = new Map();
 
   constructor(directory) {
+    super(undefined, { name: "" });
     this.directory = directory;
   }
 
-  get name() {
-    return "";
-  }
-
   get world() {
     return this;
   }
@@ -216,10 +263,6 @@ export class World {
     return this._loadType(name, Host);
   }
 
-  addHost(host) {}
-  addNetwork(network) {}
-  network(name) {}
-
   async *subnets() {
     for await (const location of this.locations()) {
       yield* location.subnets();
@@ -235,6 +278,156 @@ export class World {
   }
 }
 
+export class Location extends Owner {
+  domain;
+  dns;
+  #administratorEmail;
+
+  static get typeName() {
+    return "location";
+  }
+
+  constructor(owner, data) {
+    super(owner, data);
+
+    const networks = data.networks;
+    delete data.networks;
+    Object.assign(this, data);
+
+    if (networks) {
+      for (const [name, data] of Object.entries(networks)) {
+        data.name = name;
+        new Network(this, data);
+      }
+
+      /*
+      for (const network of this.#networks.values()) {
+        if (network.bridges) {
+          network.bridges = new Set(
+            network.bridges.map(b => {
+              const n = this.network(b);
+              if (!n) {
+                console.error(`No network named ${b}`);
+              }
+              return n;
+            })
+          );
+        }
+      }
+      */
+    }
+  }
+
+  async *hosts() {
+    for await (const host of this.owner.hosts()) {
+      if (host.location === this) {
+        yield host;
+      }
+    }
+  }
+
+  async service(filter) {
+    let best;
+    for await (const service of this.services(filter)) {
+      if (!best || service.priority < best.priority) {
+        best = service;
+      }
+    }
+
+    return best;
+  }
+
+  async *services(filter) {
+    for await (const host of this.hosts()) {
+      for (const service of Object.values(host.services)) {
+        if (
+          !filter ||
+          filter.type === "*" ||
+          filter.type === service.type ||
+          filter.name === service.name
+        ) {
+          yield service;
+        }
+      }
+    }
+  }
+
+  async *networkAddresses() {
+    for await (const host of this.hosts()) {
+      for (const networkAddresses of host.networkAddresses()) {
+        yield networkAddresses;
+      }
+    }
+  }
+
+  get dnsAllowedUpdates() {
+    return this.dns?.allowedUpdates || [];
+  }
+
+  get dnsRecordTTL() {
+    return this.dns?.recordTTL || "1W";
+  }
+
+  get administratorEmail() {
+    return this.#administratorEmail || "admin@" + this.domain;
+  }
+
+  get propertyNames() {
+    return [...super.propertyNames, "domain" /*, "hosts"*/];
+  }
+}
+
+export class Network extends Owner {
+  kind;
+  scope;
+  metric;
+  ipv4;
+  subnet;
+
+  static get typeName() {
+    return "network";
+  }
+
+  constructor(owner, data) {
+    super(owner, data);
+
+    Object.assign(this, data);
+
+    const subnetAddress = this.subnetAddress;
+
+    if (subnetAddress) {
+      let subnet = owner.subnet(subnetAddress);
+      if (!subnet) {
+        subnet = new Subnet(owner, { name: subnetAddress });
+      }
+
+      this.subnet = subnet;
+      subnet.networks.add(this);
+    }
+
+    owner.addNetwork(this);
+  }
+
+  get ipv4_netmask() {
+    const m = this.ipv4?.match(/\/(\d+)$/);
+    if (m) {
+      return m[1];
+    }
+  }
+
+  get subnetAddress() {
+    if (this.ipv4) {
+      const [addr, bits] = this.ipv4.split(/\//);
+      const parts = addr.split(/\./);
+      return parts.slice(0, bits / 8).join(".");
+    }
+  }
+
+  get propertyNames() {
+    return [...super.propertyNames, "kind", "ipv4", "scope", "metric"];
+  }
+}
+
 export class Host extends Base {
   networkInterfaces = {};
   services = {};
@@ -318,7 +511,14 @@ export class Host extends Base {
       iface.host = this;
       iface.name = name;
       if (iface.network) {
-        iface.network = this.network(iface.network);
+        const network = owner.network(iface.network);
+
+        if (!network) {
+          console.error(`${this.toString()}: Missing network`, iface.network);
+        } else {
+          iface.network = network;
+          network.addHost(this);
+        }
       }
     }
 
@@ -447,185 +647,11 @@ export class Host extends Base {
 
 export class Model extends Host {}
 
-export class Location extends Base {
-  domain;
-  dns;
-  #administratorEmail;
-  #hosts = new Map();
-  #networks = new Map();
-  #subnets = new Map();
-
-  static get typeName() {
-    return "location";
-  }
-
-  constructor(owner, data) {
-    super(owner, data);
-
-    const networks = data.networks;
-    delete data.networks;
-    Object.assign(this, data);
-
-    if (networks) {
-      for (const [name, network] of Object.entries(networks)) {
-        network.name = name;
-        this.addNetwork(network);
-      }
-
-      for (const network of this.#networks.values()) {
-        if (network.bridges) {
-          network.bridges = new Set(
-            network.bridges.map(b => {
-              const n = this.network(b);
-              if (!n) {
-                console.error(`No network named ${b}`);
-              }
-              return n;
-            })
-          );
-        }
-      }
-    }
-  }
-
-  async *hosts() {
-    for await (const host of this.owner.hosts()) {
-      if (host.location === this) {
-        yield host;
-      }
-    }
-  }
-
-  async service(filter) {
-    let best;
-    for await (const service of this.services(filter)) {
-      if (!best || service.priority < best.priority) {
-        best = service;
-      }
-    }
-
-    return best;
-  }
-
-  async *services(filter) {
-    for await (const host of this.hosts()) {
-      for (const service of Object.values(host.services)) {
-        if (
-          !filter ||
-          filter.type === "*" ||
-          filter.type === service.type ||
-          filter.name === service.name
-        ) {
-          yield service;
-        }
-      }
-    }
-  }
-
-  async *networkAddresses() {
-    for await (const host of this.hosts()) {
-      for (const networkAddresses of host.networkAddresses()) {
-        yield networkAddresses;
-      }
-    }
-  }
-
-  async network(name) {
-    return this.#networks.get(name);
-  }
-
-  async *networks() {
-    for (const network of this.#networks.values()) {
-      yield network;
-    }
-  }
-
-  async *subnets() {
-    for (const subnet of this.#subnets.values()) {
-      yield subnet;
-    }
-  }
-
-  addNetwork(data) {
-    if (!data?.name) {
-      return undefined;
-    }
-
-    let network = this.#networks.get(data.name);
-    if (network) {
-      return network;
-    }
-
-    if(data instanceof Network) {
-      this.#networks.set(data.name, data);
-      return data;
-    }
-
-    network = new Network(this, data);
-    this.#networks.set(data.name, network);
-
-    const subnetAddress = network.subnetAddress;
-
-    if (subnetAddress) {
-      let subnet = this.#subnets.get(subnetAddress);
-      if (!subnet) {
-        subnet = new Subnet(this, subnetAddress);
-        this.#subnets.set(subnetAddress, subnet);
-      }
-      network.subnet = subnet;
-      subnet.networks.add(network);
-    }
-    return network;
-  }
-
-  addHost(host) {
-    this.#hosts.set(host.name, host);
-
-    for (const [name, iface] of Object.entries(host.networkInterfaces)) {
-      const network = this.addNetwork({ name: iface.network });
-      if (!network) {
-        console.error("Missing network", host.name, name);
-      } else {
-        network.addHost(host);
-      }
-    }
-  }
-
-  get dnsAllowedUpdates() {
-    return this.dns?.allowedUpdates || [];
-  }
-
-  get dnsRecordTTL() {
-    return this.dns?.recordTTL || "1W";
-  }
-
-  get administratorEmail() {
-    return this.#administratorEmail || "admin@" + this.domain;
-  }
-
-  get propertyNames() {
-    return [...super.propertyNames, "domain" /*, "hosts"*/];
-  }
-
-  toJSON() {
-    return {
-      ...super.toJSON(),
-      hosts: [...this.#hosts.keys()].sort()
-    };
-  }
-}
-
-export class Network extends Base {
-  #hosts = new Map();
-  kind;
-  scope;
-  metric;
-  ipv4;
-  ipv4_netmask;
-  subnet;
+export class Subnet extends Base {
+  networks = new Set();
 
   static get typeName() {
-    return "network";
+    return "subnet";
   }
 
   constructor(owner, data) {
@@ -633,48 +659,7 @@ export class Network extends Base {
 
     Object.assign(this, data);
 
-    if (this.ipv4) {
-      const m = this.ipv4.match(/\/(\d+)$/);
-      if (m) {
-        this.ipv4_netmask = m[1];
-      }
-    }
-
-    owner.addNetwork(this);
-  }
-
-  get subnetAddress() {
-    if (this.ipv4) {
-      const [addr, bits] = this.ipv4.split(/\//);
-      const parts = addr.split(/\./);
-      return parts.slice(0, bits / 8).join(".");
-    }
-  }
-
-  async *hosts() {
-    for (const host of this.#hosts.values()) {
-      yield host;
-    }
-  }
-
-  addHost(host) {
-    this.#hosts.set(host.name, host);
-  }
-
-  get propertyNames() {
-    return [...super.propertyNames, "kind", "ipv4", "scope", "metric"];
-  }
-}
-
-export class Subnet extends Base {
-  networks = new Set();
-
-  static get typeName() {
-    return "subnet";
-  }
-
-  constructor(owner, address) {
-    super(owner, { name: address });
+    owner.addSubnet(this);
   }
 
   get address() {

package/types/model.d.mts

@@ -23,13 +23,27 @@ export class Base {
     toJSON(): {};
     #private;
 }
-export class World {
+export class Owner extends Base {
+    hosts(): AsyncGenerator<any, void, unknown>;
+    addHost(host: any): void;
+    network(name: any): any;
+    networks(): AsyncGenerator<any, void, unknown>;
+    addNetwork(network: any): void;
+    addSubnet(subnet: any): void;
+    subnet(name: any): any;
+    subnets(): MapIterator<any>;
+    toJSON(): {
+        networks: any[];
+        subnets: any[];
+        hosts: any[];
+    };
+    #private;
+}
+export class World extends Owner {
     static get types(): {
         [k: string]: typeof Location | typeof Host | typeof Network | typeof Subnet | typeof Service;
     };
     constructor(directory: any);
-    directory: any;
-    get name(): string;
     get world(): this;
     _loadType(name: any, type: any): Promise<any>;
     load(): Promise<void>;
@@ -39,9 +53,6 @@ export class World {
     domains(): AsyncGenerator<any, void, unknown>;
     location(name: any): Promise<any>;
     host(name: any): Promise<any>;
-    addHost(host: any): void;
-    addNetwork(network: any): void;
-    network(name: any): void;
     subnets(): AsyncGenerator<any, void, unknown>;
     networkAddresses(): AsyncGenerator<{
         address: any;
@@ -49,6 +60,26 @@ export class World {
     }, void, unknown>;
     #private;
 }
+export class Location extends Owner {
+    domain: any;
+    dns: any;
+    service(filter: any): Promise<any>;
+    services(filter: any): AsyncGenerator<any, void, unknown>;
+    networkAddresses(): AsyncGenerator<any, void, unknown>;
+    get dnsAllowedUpdates(): any;
+    get dnsRecordTTL(): any;
+    get administratorEmail(): any;
+    #private;
+}
+export class Network extends Owner {
+    kind: any;
+    scope: any;
+    metric: any;
+    ipv4: any;
+    subnet: any;
+    get ipv4_netmask(): any;
+    get subnetAddress(): any;
+}
 export class Host extends Base {
     static prepareData(world: any, data: any): Promise<typeof Host>;
     networkInterfaces: {};
@@ -82,37 +113,6 @@ export class Host extends Base {
 }
 export class Model extends Host {
 }
-export class Location extends Base {
-    domain: any;
-    dns: any;
-    hosts(): AsyncGenerator<any, void, unknown>;
-    service(filter: any): Promise<any>;
-    services(filter: any): AsyncGenerator<any, void, unknown>;
-    networkAddresses(): AsyncGenerator<any, void, unknown>;
-    networks(): AsyncGenerator<any, void, unknown>;
-    subnets(): AsyncGenerator<any, void, unknown>;
-    addNetwork(data: any): any;
-    addHost(host: any): void;
-    get dnsAllowedUpdates(): any;
-    get dnsRecordTTL(): any;
-    get administratorEmail(): any;
-    toJSON(): {
-        hosts: any[];
-    };
-    #private;
-}
-export class Network extends Base {
-    kind: any;
-    scope: any;
-    metric: any;
-    ipv4: any;
-    ipv4_netmask: any;
-    subnet: any;
-    get subnetAddress(): any;
-    hosts(): AsyncGenerator<any, void, unknown>;
-    addHost(host: any): void;
-    #private;
-}
 export class Subnet extends Base {
     networks: Set<any>;
     get address(): any;