pmcf 1.5.1 → 1.5.3

package/bin/pmcf-host-defs

@@ -5,18 +5,16 @@ import { join } from "node:path";
 import { writeLines, sectionLines } from "../src/model.mjs";
 import { prepare } from "../src/cmd.mjs";
 
-const { world, args } = prepare();
+const { world, args, options } = prepare();
 
 const hostName = args[0];
 
 const host = await world.host(hostName);
 
-const targetDir = args[1] || `pkg/host-${host.hostName}`;
-
-await generateNetworkDefs(host, targetDir);
-await generateMachineInfo(host, targetDir);
-await copySshKeys(host, targetDir);
-await generateKnownHosts(world.hosts(), join(targetDir, "root", ".ssh"));
+await generateNetworkDefs(host, options.output);
+await generateMachineInfo(host, options.output);
+await copySshKeys(host, options.output);
+await generateKnownHosts(world.hosts(), join(options.output, "root", ".ssh"));
 
 console.log("provides", "host", ...host.provides);
 console.log("depends", `location-${host.location.name}`, ...host.depends);

package/bin/pmcf-location-defs

@@ -5,12 +5,11 @@ import { join } from "node:path";
 import { writeLines, sectionLines } from "../src/model.mjs";
 import { prepare } from "../src/cmd.mjs";
 
-const { world, args } = prepare();
+const { world, args, options } = prepare();
 
 const location = await world.location(args[0] || "SW");
-const targetDir = args[1];
 
-await generateLocationDefs(location, targetDir);
+await generateLocationDefs(location, options.output);
 
 console.log(
   "provides",

package/bin/pmcf-named-defs

@@ -5,10 +5,9 @@ import { createHmac } from "node:crypto";
 import { writeLines } from "../src/model.mjs";
 import { prepare } from "../src/cmd.mjs";
 
-const { world, args } = prepare();
+const { world, args, options } = prepare();
 
 const location = await world.location(args[0] || "SW");
-const targetDir = args[1] || `pkg/mf-named-${location.name}`;
 const ttl = location.dnsRecordTTL;
 const updates = [
   Math.ceil(Date.now() / 1000),
@@ -20,7 +19,7 @@ const updates = [
 
 const NAME_LEN = 35;
 
-await generateNamedDefs(location, targetDir);
+await generateNamedDefs(location, options.output);
 
 console.log("depends", "mf-named");
 console.log("replaces", "mf-named-zones");

package/package.json

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

package/src/model.mjs

@@ -69,7 +69,7 @@ export class Base {
     return this.owner.host;
   }
 
-  network(name) {
+  async network(name) {
     return this.owner.network(name);
   }
 
@@ -113,22 +113,24 @@ export class Base {
   }
 }
 
-export class World {
+export class Owner extends Base {
+  addHost(host) {}
+  addNetwork(network) {}
+  async network(name) {}
+}
+
+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;
   }
@@ -161,7 +163,7 @@ export class World {
 
       type = await type.prepareData(this, data);
       object = new type(owner, data);
-      this.#byName.set(data.name, object);
+      this.#byName.set(object.name, object);
     }
 
     return object;
@@ -216,9 +218,6 @@ export class World {
     return this._loadType(name, Host);
   }
 
-  addHost(host) {}
-  network(name) {}
-
   async *subnets() {
     for await (const location of this.locations()) {
       yield* location.subnets();
@@ -234,6 +233,225 @@ export class World {
   }
 }
 
+export class Location extends Owner {
+  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;
+
+  static get typeName() {
+    return "network";
+  }
+
+  constructor(owner, data) {
+    super(owner, data);
+
+    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 Host extends Base {
   networkInterfaces = {};
   services = {};
@@ -446,224 +664,6 @@ 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 load() {
-    for await (const host of this.owner.hosts());
-  }
-
-  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;
-        }
-      }
-    }
-  }
-
-  network(name) {
-    return this.#networks.get(name);
-  }
-
-  async *networkAddresses() {
-    await this.load();
-    for await (const host of this.hosts()) {
-      for (const networkAddresses of host.networkAddresses()) {
-        yield networkAddresses;
-      }
-    }
-  }
-
-  async *networks() {
-    await this.load();
-    for (const network of this.#networks.values()) {
-      yield network;
-    }
-  }
-
-  async *subnets() {
-    await this.load();
-    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;
-    }
-
-    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"];
-  }
-
-  toJSON() {
-    return {
-      ...super.toJSON(),
-      hosts: [...this.#hosts.keys()].sort()
-    };
-  }
-}
-
-export class Network extends Base {
-  #hosts = new Map();
-  kind;
-  scope;
-  metric;
-  ipv4;
-  ipv4_netmask;
-  subnet;
-
-  static get typeName() {
-    return "network";
-  }
-
-  constructor(owner, data) {
-    super(owner, data);
-
-    Object.assign(this, data);
-
-    if (this.ipv4) {
-      const m = this.ipv4.match(/\/(\d+)$/);
-      if (m) {
-        this.ipv4_netmask = m[1];
-      }
-    }
-  }
-
-  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();
@@ -808,8 +808,13 @@ function extractFrom(object, propertyNames) {
   const json = {};
   for (const p of propertyNames) {
     const value = object[p];
+
     if (value !== undefined) {
-      json[p] = value;
+      if (value instanceof Base) {
+        json[p] = { name: object.name };
+      } else {
+        json[p] = value;
+      }
     }
   }
   return json;

package/types/model.d.mts

@@ -14,7 +14,7 @@ export class Base {
     get world(): any;
     get location(): any;
     get host(): any;
-    network(name: any): any;
+    network(name: any): Promise<any>;
     set directory(directory: any);
     get directory(): any;
     expand(object: any): any;
@@ -23,13 +23,16 @@ export class Base {
     toJSON(): {};
     #private;
 }
-export class World {
+export class Owner extends Base {
+    addHost(host: any): void;
+    addNetwork(network: any): void;
+    network(name: any): Promise<void>;
+}
+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,8 +42,6 @@ export class World {
     domains(): AsyncGenerator<any, void, unknown>;
     location(name: any): Promise<any>;
     host(name: any): Promise<any>;
-    addHost(host: any): void;
-    network(name: any): void;
     subnets(): AsyncGenerator<any, void, unknown>;
     networkAddresses(): AsyncGenerator<{
         address: any;
@@ -48,6 +49,37 @@ export class World {
     }, void, unknown>;
     #private;
 }
+export class Location extends Owner {
+    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>;
+    network(name: any): Promise<any>;
+    networks(): AsyncGenerator<any, void, unknown>;
+    subnets(): AsyncGenerator<any, void, unknown>;
+    addNetwork(data: any): any;
+    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 Host extends Base {
     static prepareData(world: any, data: any): Promise<typeof Host>;
     networkInterfaces: {};
@@ -81,38 +113,6 @@ export class Host extends Base {
 }
 export class Model extends Host {
 }
-export class Location extends Base {
-    domain: any;
-    dns: any;
-    load(): Promise<void>;
-    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;