pmcf 1.28.0 → 1.30.0

package/bin/pmcf-host-defs

@@ -4,18 +4,18 @@ import { writeFile, mkdir, copyFile, glob, chmod } from "node:fs/promises";
 import { join } from "node:path";
 import { Host } from "pmcf";
 import { writeLines, sectionLines } from "../src/utils.mjs";
-import { prepare, } from "../src/cmd.mjs";
+import { prepare } from "../src/cmd.mjs";
 
-const { world, args, options } = prepare();
+const { root, args, options } = await prepare();
 
 const hostName = args[0];
 
-const host = await world.load(hostName,{ type: Host });
+const host = await root.load(hostName, { type: Host });
 
 await generateNetworkDefs(host, options.output);
 await generateMachineInfo(host, options.output);
 await copySshKeys(host, options.output);
-await generateKnownHosts(world.hosts(), join(options.output, "root", ".ssh"));
+await generateKnownHosts(root.hosts(), join(options.output, "root", ".ssh"));
 
 console.log("provides", "host", ...host.provides);
 console.log("depends", `location-${host.location.name}`, ...host.depends);
@@ -153,7 +153,10 @@ async function copySshKeys(host, dir) {
   for await (const file of glob("ssh_host_*", { cwd: host.directory })) {
     const destinationFileName = join(sshDir, file);
     await copyFile(join(host.directory, file), destinationFileName);
-    await chmod(destinationFileName, destinationFileName.endsWith('.pub') ? 0o0644 : 0o0600);
+    await chmod(
+      destinationFileName,
+      destinationFileName.endsWith(".pub") ? 0o0644 : 0o0600
+    );
   }
 }
 

package/bin/pmcf-info

@@ -1,15 +1,15 @@
 #!/usr/bin/env node
 import { prepare } from "../src/cmd.mjs";
-const { world, args } = prepare();
+const { root, args } = await prepare();
 
 const objectName = args[0];
 
 if (objectName) {
-  const object = await world.named(objectName);
+  const object = root.named(objectName);
   console.log(object.toJSON());
 } else {
-  for await (const location of world.locations()) {
+  for await (const location of root.locations()) {
     console.log(location.name);
-    console.log("  ", (await location.service({ type: "dns"}))?.toString());
+    console.log("  ", (await location.service({ type: "dns" }))?.toString());
   }
 }

package/bin/pmcf-location-defs

@@ -6,9 +6,9 @@ import { Location } from "pmcf";
 import { writeLines, sectionLines } from "../src/utils.mjs";
 import { prepare } from "../src/cmd.mjs";
 
-const { world, args, options } = prepare();
+const { root, args, options } = await prepare();
 
-const location = await world.load(args[0], { type: Location });
+const location = await root.load(args[0], { type: Location });
 
 await generateLocationDefs(location, options.output);
 

package/bin/pmcf-named-defs

@@ -9,9 +9,9 @@ import {
 } from "../src/utils.mjs";
 import { prepare } from "../src/cmd.mjs";
 
-const { world, args, options } = prepare();
+const { root, args, options } = await prepare();
 
-const owner = await world.load(args[0]);
+const owner = await root.load(args[0]);
 const updates = [
   Math.ceil(Date.now() / 1000),
   36000,
@@ -42,7 +42,7 @@ async function generateNamedDefs(owner, targetDir) {
     const createRecord = (key, type, value) => {
       return {
         key,
-       /*type,
+        /*type,
         value,*/
         toString: () =>
           `${key.padEnd(maxKeyLength, " ")} ${ttl} IN ${type.padEnd(

package/bin/pmcf-network

@@ -2,9 +2,9 @@
 
 import { prepare } from "../src/cmd.mjs";
 
-const { world, args } = prepare();
+const { root, args } = await prepare();
 
-const location = await world.load(args[0]);
+const location = await root.load(args[0]);
 
 function q(str) {
   return str.match(/^\w+$/) ? str : `"${str}"`;

package/package.json

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

package/src/base.mjs

@@ -9,6 +9,14 @@ export class Base {
   static get typeName() {
     return "base";
   }
+  
+  static get pluralTypeName() {
+    return this.typeName + "s";
+  }
+
+  static get nameLookupName() {
+    return this.typeName + "Named";
+  }
 
   static get typeFileName() {
     return this.typeName + ".json";
@@ -18,16 +26,14 @@ export class Base {
     return "**/" + this.typeFileName;
   }
 
-  static async prepareData(world, data) {
+  static async prepareData(root, data) {
     return this;
   }
 
-  static baseName(name) {
-    if (!name) {
-      return undefined;
+  static normalizeName(name) {
+    if (name !== undefined) {
+      return name.replace(/\/\w+\.json$/, "");
     }
-
-    return name.replace(/\/\w+\.json$/, "");
   }
 
   constructor(owner, data) {
@@ -55,8 +61,8 @@ export class Base {
     return this.constructor.typeName;
   }
 
-  get world() {
-    return this.owner.world;
+  get root() {
+    return this.owner.root;
   }
 
   get location() {
@@ -85,7 +91,7 @@ export class Base {
   }
 
   get fullName() {
-    return this.owner?.fullName
+    return this.owner && this.name
       ? join(this.owner.fullName, this.name)
       : this.name;
   }

package/src/cluster.mjs

@@ -7,7 +7,6 @@ export class Cluster extends Owner {
 
   constructor(owner, data) {
     super(owner, data);
-
-    owner.addCluster(this);
+    owner.addObject(this);
   }
 }

package/src/cmd.mjs

@@ -1,15 +1,15 @@
 import { parseArgs } from "node:util";
 import { argv, cwd, env } from "node:process";
-import { World } from "./model.mjs";
+import { Root } from "./model.mjs";
 
-export function prepare() {
+export async function prepare() {  
   const { values, positionals } = parseArgs({
     args: argv.slice(2),
     options: {
-      world: {
+      root: {
         type: "string",
-        short: "w",
-        default: env.PMCF_WORLD || cwd()
+        short: "r",
+        default: env.PMCF_ROOT || cwd()
       },
       output: {
         type: "string",
@@ -20,7 +20,9 @@ export function prepare() {
     allowPositionals: true
   });
 
-  const world = new World(values.world);
+  const root = new Root(values.root);
 
-  return { world, options: values, args: positionals };
+  await root.loadAll();
+  
+  return { root, options: values, args: positionals };
 }

package/src/dns.mjs

@@ -13,6 +13,7 @@ export class DNSService extends Base {
   constructor(owner, data) {
     super(owner, data);
     Object.assign(this, data);
+    owner.addObject(this);
   }
 
   async *services() {
@@ -21,7 +22,7 @@ export class DNSService extends Base {
     yield* this.owner.services(filter);
 
     for (const s of asArray(this.forwardsTo)) {
-      const owner = await this.owner.world.load(s);
+      const owner = await this.owner.root.load(s);
       yield* owner.services(filter);
     }
   }

package/src/model.mjs

@@ -12,99 +12,87 @@ import { Service } from "./service.mjs";
 import { Cluster } from "./cluster.mjs";
 import { DNSService } from "./dns.mjs";
 
-export class World extends Owner {
+export class Root extends Owner {
   static get types() {
     return _typesByName;
   }
 
   static get typeName() {
-    return "world";
+    return "root";
   }
 
-  #byName = new Map();
-
   constructor(directory) {
     super(undefined, { name: "" });
     this.directory = directory;
     this.addObject(this);
   }
 
-  _traverse(...args) {
-    if (super._traverse(...args)) {
-      for (const object of this.#byName.values()) {
-        object._traverse(...args);
-      }
-
-      return true;
-    }
-
-    return false;
-  }
-
   get fullName() {
     return "";
   }
 
-  get world() {
+  get root() {
     return this;
   }
 
   async load(name, options) {
-    if (name === "") {
-      return this;
-    }
-    const baseName = Base.baseName(name);
-
-    let object = this.#byName.get(baseName);
-
-    if (!object) {
-      let path = baseName.split("/");
-      path.pop();
-
-      let data;
-      let type = options?.type;
-      if (type) {
-        data = JSON.parse(
-          await readFile(
-            join(this.directory, baseName, type.typeFileName),
-            "utf8"
-          )
-        );
-      } else {
-        for (type of _types) {
-          try {
-            data = JSON.parse(
-              await readFile(
-                join(this.directory, baseName, type.typeFileName),
-                "utf8"
-              )
-            );
-            break;
-          } catch {}
-        }
-
-        if (!data) {
-          return this.load(path.join("/"), options);
-        }
-      }
+    const fullName = Base.normalizeName(name);
+    let object = this.named(fullName);
+    if (object) {
+      return object;
+    }
 
-      const owner = await this.load(path.join("/"));
+    //console.log("LOAD", fullName);
 
-      const length = owner.fullName.length;
-      const n = baseName[length] === "/" ? length + 1 : length;
-      data.name = baseName.substring(n);
+    let path = fullName.split("/");
+    path.pop();
 
-      type = await type.prepareData(this, data);
+    let data;
+    let type = options?.type;
+    if (type) {
+      data = JSON.parse(
+        await readFile(
+          join(this.directory, fullName, type.typeFileName),
+          "utf8"
+        )
+      );
+    } else {
+      for (type of _types) {
+        try {
+          data = JSON.parse(
+            await readFile(
+              join(this.directory, fullName, type.typeFileName),
+              "utf8"
+            )
+          );
+          break;
+        } catch {}
+      }
 
-      object = new type(owner, data);
-      this.addObject(object);
+      if (!data) {
+        return this.load(path.join("/"), options);
+      }
     }
 
+    const owner = await this.load(path.join("/"));
+
+    const length = owner.fullName.length;
+    const n = fullName[length] === "/" ? length + 1 : length;
+    data.name = fullName.substring(n);
+
+    type = await type.prepareData(this, data);
+
+    object = new type(owner, data);
+
+    this._addObject(type.typeName, fullName, object);
+
+    //console.log("FINISH LOAD", object.fullName);
+
     return object;
   }
 
   async loadAll() {
-    for (let type of Object.values(World.types)) {
+    for (let type of Object.values(Root.types)) {
       for await (const name of glob(type.fileNameGlob, {
         cwd: this.directory
       })) {
@@ -114,41 +102,6 @@ export class World extends Owner {
 
     this.execFinalize();
   }
-
-  addObject(object) {
-    this.#byName.set(object.fullName, object);
-  }
-
-  async named(name) {
-    await this.loadAll();
-    return this.#byName.get(name);
-  }
-
-  async *locations() {
-    await this.loadAll();
-
-    for (const object of this.#byName.values()) {
-      if (object instanceof Location) {
-        yield object;
-      }
-    }
-  }
-
-  async *hosts() {
-    await this.loadAll();
-
-    for (const object of this.#byName.values()) {
-      if (object instanceof Host) {
-        yield object;
-      }
-    }
-  }
-
-  async *domains() {
-    for await (const location of this.locations()) {
-      yield location.domain;
-    }
-  }
 }
 
 export class Location extends Owner {
@@ -159,17 +112,8 @@ export class Location extends Owner {
   get location() {
     return this;
   }
-
-  async *hosts() {
-    for await (const host of this.owner.hosts()) {
-      if (host.location === this) {
-        yield host;
-      }
-    }
-  }
 }
 
-
 export class Host extends Base {
   networkInterfaces = {};
   postinstall = [];
@@ -189,14 +133,14 @@ export class Host extends Base {
     return "host";
   }
 
-  static async prepareData(world, data) {
+  static async prepareData(root, data) {
     if (data.location) {
-      data.location = await world.load(data.location, { type: Location });
+      data.location = await root.load(data.location, { type: Location });
     }
 
     if (data.extends) {
       data.extends = await Promise.all(
-        asArray(data.extends).map(e => world.load(e, { type: Host }))
+        asArray(data.extends).map(e => root.load(e, { type: Host }))
       );
     }
 
@@ -268,7 +212,7 @@ export class Host extends Base {
       new NetworkInterface(this, iface);
     }
 
-    owner.addHost(this);
+    owner.addObject(this);
   }
 
   _traverse(...args) {
@@ -385,7 +329,7 @@ export class Host extends Base {
     this.networkInterfaces[networkInterface.name] = networkInterface;
 
     if (networkInterface.network) {
-      networkInterface.network.addHost(this);
+      networkInterface.network.addObject(this);
     }
   }
 
@@ -398,7 +342,9 @@ export class Host extends Base {
   }
 
   get ipAddresses() {
-    return [...this.networkAddresses()].map(na => normalizeIPAddress(na.address));
+    return [...this.networkAddresses()].map(na =>
+      normalizeIPAddress(na.address)
+    );
   }
 
   get ipAddress() {
@@ -588,6 +534,5 @@ export class NetworkInterface extends Base {
   }
 }
 
-
 const _types = [Location, Network, Subnet, Host, Cluster, Service, DNSService];
 const _typesByName = Object.fromEntries(_types.map(t => [t.typeName, t]));

package/src/owner.mjs

@@ -1,13 +1,9 @@
 import { asArray, bridgeToJSON } from "./utils.mjs";
-
 import { Base } from "./base.mjs";
 import { DNSService } from "./dns.mjs";
 
 export class Owner extends Base {
-  #hosts = new Map();
-  #clusters = new Map();
-  #networks = new Map();
-  #subnets = new Map();
+  #membersByType = new Map();
   #bridges = new Set();
   #dns;
   #administratorEmail;
@@ -35,20 +31,16 @@ export class Owner extends Base {
       }
     }
     Object.assign(this, data);
+
+    owner?.addObject(this);
   }
 
   _traverse(...args) {
     if (super._traverse(...args)) {
-      for (const network of this.#networks.values()) {
-        network._traverse(...args);
-      }
-
-      for (const host of this.#hosts.values()) {
-        host._traverse(...args);
-      }
-
-      for (const cluster of this.#clusters.values()) {
-        cluster._traverse(...args);
+      for (const typeSlot of this.#membersByType.values()) {
+        for (const object of typeSlot.values()) {
+          object._traverse(...args);
+        }
       }
 
       return true;
@@ -61,24 +53,44 @@ export class Owner extends Base {
     return this.#dns;
   }
 
-  async *hosts() {
-    for (const host of this.#hosts.values()) {
-      yield host;
+  named(name) {
+    //console.log("NAMED", this.#membersByType.keys());
+    for (const slot of this.#membersByType.values()) {
+      const object = slot.get(name);
+      if (object) {
+        return object;
+      }
     }
   }
 
-  addObject(object) {
-    this.world.addObject(object);
+  typeNamed(typeName, name) {
+    const typeSlot = this.#membersByType.get(typeName);
+    return typeSlot?.get(name);
   }
 
-  addHost(host) {
-    this.#hosts.set(host.name, host);
-    this.addObject(host);
+  *typeList(typeName) {
+    const typeSlot = this.#membersByType.get(typeName);
+    if (typeSlot) {
+      for (const object of typeSlot.values()) {
+        yield object;
+      }
+    }
   }
 
-  addCluster(cluster) {
-    this.#clusters.set(cluster.name, cluster);
-    this.addObject(cluster);
+  _addObject(typeName, fullName, object) {
+    let typeSlot = this.#membersByType.get(typeName);
+    if (!typeSlot) {
+      typeSlot = new Map();
+      this.#membersByType.set(typeName, typeSlot);
+    }
+    typeSlot.set(fullName, object);
+
+    //console.log(this.toString(),"ADD", typeName, fullName, object.name, this.named(fullName)?.toString());
+  }
+
+  addObject(object) {
+    this.owner?.addObject(object);
+    this._addObject(object.typeName, object.fullName, object);
   }
 
   async service(filter) {
@@ -100,19 +112,44 @@ export class Owner extends Base {
     }
   }
 
+  locationNamed(name) {
+    return this.typeNamed("location", name);
+  }
+
+  locations() {
+    return this.typeList("location");
+  }
+
+  hostNamed(name) {
+    return this.typeNamed("host", name);
+  }
+
+  hosts() {
+    return this.typeList("host");
+  }
+
   networkNamed(name) {
-    //console.log(this.toString(), name, this.#networks.keys());
-    return this.#networks.get(name);
+    return this.typeNamed("network", name);
   }
 
-  async *networks() {
-    for (const network of this.#networks.values()) {
-      yield network;
-    }
+  networks() {
+    return this.typeList("network");
+  }
+
+  subnetNamed(name) {
+    return this.typeNamed("subnet", name);
   }
 
-  addNetwork(network) {
-    this.#networks.set(network.fullName, network);
+  subnets() {
+    return this.typeList("subnet");
+  }
+
+  clusterNamed(name) {
+    return this.typeNamed("cluster", name);
+  }
+
+  clusters() {
+    return this.typeList("cluster");
   }
 
   addBridge(network, destinationNetworks) {
@@ -178,34 +215,28 @@ export class Owner extends Base {
     }
   }
 
-  addSubnet(subnet) {
-    this.#subnets.set(subnet.name, subnet);
-  }
-
-  subnet(name) {
-    return this.#subnets.get(name);
-  }
-
-  subnets() {
-    return this.#subnets.values();
-  }
-
   get administratorEmail() {
     return this.#administratorEmail || "admin@" + this.domain;
   }
 
+  *domains() {
+    for (const location of this.locations()) {
+      yield location.domain;
+    }
+  }
+
   get propertyNames() {
     return [...super.propertyNames, "domain", "administratorEmail", "dns"];
   }
 
   toJSON() {
-    return {
-      ...super.toJSON(),
-      networks: [...this.#networks.keys()].sort(),
-      subnets: [...this.#subnets.keys()].sort(),
-      bridges: [...this.#bridges].map(b => bridgeToJSON(b)),
-      hosts: [...this.#hosts.keys()].sort()
-    };
+    const json = super.toJSON();
+
+    for (const [typeName, slot] of this.#membersByType) {
+      json[typeName] = [...slot.keys()].sort();
+    }
+
+    return json;
   }
 }
 
@@ -235,7 +266,7 @@ export class Network extends Owner {
     const subnetAddress = this.subnetAddress;
 
     if (subnetAddress) {
-      let subnet = owner.subnet(subnetAddress);
+      let subnet = owner.subnetNamed(subnetAddress);
       if (!subnet) {
         subnet = new Subnet(owner, { name: subnetAddress });
       }
@@ -244,7 +275,7 @@ export class Network extends Owner {
       subnet.networks.add(this);
     }
 
-    owner.addNetwork(this);
+    owner.addObject(this);
 
     this.bridge = owner.addBridge(this, bridge);
   }
@@ -289,7 +320,7 @@ export class Subnet extends Base {
 
     Object.assign(this, data);
 
-    owner.addSubnet(this);
+    owner.addObject(this);
   }
 
   get address() {

package/types/base.d.mts

@@ -1,17 +1,19 @@
 export function extractFrom(object: any, propertyNames: any): {};
 export class Base {
     static get typeName(): string;
+    static get pluralTypeName(): string;
+    static get nameLookupName(): string;
     static get typeFileName(): string;
     static get fileNameGlob(): string;
-    static prepareData(world: any, data: any): Promise<typeof Base>;
-    static baseName(name: any): any;
+    static prepareData(root: any, data: any): Promise<typeof Base>;
+    static normalizeName(name: any): any;
     constructor(owner: any, data: any);
     owner: any;
     name: any;
     description: any;
     withOwner(owner: any): any;
     get typeName(): any;
-    get world(): any;
+    get root(): any;
     get location(): any;
     get host(): any;
     get network(): any;

package/types/cmd.d.mts

@@ -1,9 +1,9 @@
-export function prepare(): {
-    world: World;
+export function prepare(): Promise<{
+    root: Root;
     options: {
-        world: string;
+        root: string;
         output: string;
     };
     args: string[];
-};
-import { World } from "./model.mjs";
+}>;
+import { Root } from "./model.mjs";

package/types/model.d.mts

@@ -1,23 +1,18 @@
-export class World extends Owner {
+export class Root extends Owner {
     static get types(): {
-        [k: string]: typeof DNSService | typeof Network | typeof Subnet | typeof Cluster | typeof Service | typeof Host;
+        [k: string]: typeof DNSService | typeof Subnet | typeof Cluster | typeof Service | typeof Host;
     };
     constructor(directory: any);
     get fullName(): string;
-    get world(): this;
+    get root(): this;
     load(name: any, options: any): any;
     loadAll(): Promise<void>;
-    named(name: any): Promise<any>;
-    locations(): AsyncGenerator<Location, void, unknown>;
-    hosts(): AsyncGenerator<Host, void, unknown>;
-    domains(): AsyncGenerator<any, void, unknown>;
-    #private;
 }
 export class Location extends Owner {
     get location(): this;
 }
 export class Host extends Base {
-    static prepareData(world: any, data: any): Promise<typeof Host>;
+    static prepareData(root: any, data: any): Promise<typeof Host>;
     networkInterfaces: {};
     postinstall: any[];
     _traverse(...args: any[]): boolean;
@@ -73,7 +68,6 @@ export class NetworkInterface extends Base {
 }
 import { Owner } from "./owner.mjs";
 import { DNSService } from "./dns.mjs";
-import { Network } from "./owner.mjs";
 import { Subnet } from "./owner.mjs";
 import { Cluster } from "./cluster.mjs";
 import { Service } from "./service.mjs";

package/types/owner.d.mts

@@ -5,27 +5,27 @@ export class Owner extends Base {
     };
     _traverse(...args: any[]): boolean;
     get dns(): DNSService;
-    hosts(): AsyncGenerator<any, void, unknown>;
+    named(name: any): any;
+    typeNamed(typeName: any, name: any): any;
+    typeList(typeName: any): Generator<any, void, unknown>;
+    _addObject(typeName: any, fullName: any, object: any): void;
     addObject(object: any): void;
-    addHost(host: any): void;
-    addCluster(cluster: any): void;
     service(filter: any): Promise<any>;
     services(filter: any): AsyncGenerator<any, void, unknown>;
+    locationNamed(name: any): any;
+    locations(): Generator<any, void, unknown>;
+    hostNamed(name: any): any;
+    hosts(): Generator<any, void, unknown>;
     networkNamed(name: any): any;
-    networks(): AsyncGenerator<any, void, unknown>;
-    addNetwork(network: any): void;
+    networks(): Generator<any, void, unknown>;
+    subnetNamed(name: any): any;
+    subnets(): Generator<any, void, unknown>;
+    clusterNamed(name: any): any;
+    clusters(): Generator<any, void, unknown>;
     addBridge(network: any, destinationNetworks: any): any;
     _resolveBridges(): void;
     networkAddresses(): AsyncGenerator<any, void, unknown>;
-    addSubnet(subnet: any): void;
-    subnet(name: any): any;
-    subnets(): MapIterator<any>;
-    toJSON(): {
-        networks: any[];
-        subnets: any[];
-        bridges: any[][];
-        hosts: any[];
-    };
+    domains(): Generator<any, void, unknown>;
     #private;
 }
 export class Network extends Owner {