pmcf 1.42.1 → 1.43.0

package/bin/pmcf-host-defs

@@ -15,7 +15,7 @@ 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(root.hosts(), join(options.output, "root", ".ssh"));
+await generateKnownHosts(host.owner.hosts(), join(options.output, "root", ".ssh"));
 
 console.log("provides", "host", ...host.provides);
 console.log("depends", `location-${host.location.name}`, ...host.depends);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pmcf",
-  "version": "1.42.1",
+  "version": "1.43.0",
   "publishConfig": {
     "access": "public"
   },
@@ -43,7 +43,7 @@
     "pacc": "^3.3.0"
   },
   "devDependencies": {
-    "@types/node": "^22.13.2",
+    "@types/node": "^22.13.4",
     "ava": "^6.2.0",
     "c8": "^10.1.3",
     "documentation": "^14.0.3",

package/src/base.mjs

@@ -1,6 +1,7 @@
 import { join } from "node:path";
 import { getAttribute } from "pacc";
 import { typesByName } from "./types.mjs";
+import { asArray } from "./utils.mjs";
 
 export class Base {
   owner;
@@ -8,19 +9,21 @@ export class Base {
   description;
 
   static get typeName() {
-    return "base";
+    return this.typeDefinition.name;
   }
 
   static get typeDefinition() {
     return {
-      //      name: { type: "string", collection: false }
+      name: "base",
+      properties: {
+        /*   name: { type: "string" },
+        description: { type: "string" },
+        directory: { type: "string" },
+        owner: {}*/
+      }
     };
   }
 
-  static get pluralTypeName() {
-    return this.typeName + "s";
-  }
-
   static get nameLookupName() {
     return this.typeName + "Named";
   }
@@ -46,28 +49,41 @@ export class Base {
   constructor(owner, data) {
     this.owner = owner;
 
-    if (data) {
-      this.name = data.name;
-      if (data.description) {
-        this.description = data.description;
+    switch (typeof data) {
+      case "string":
+        this.name = data;
+        break;
+      case "object": {
+        this.name = data.name;
+        if (data.description) {
+          this.description = data.description;
+        }
       }
     }
   }
 
   read(data) {
     for (const [slotName, typeDef] of Object.entries(
-      this.constructor.typeDefinition
+      this.constructor.typeDefinition.properties
     )) {
       const slot = data[slotName];
       if (slot) {
         delete data[slotName];
         if (typeDef.collection) {
-          for (const [objectName, objectData] of Object.entries(slot)) {
-            objectData.name = objectName;
-            new typesByName[typeDef.type](this, objectData);
+          if (Array.isArray(slot) || typeof slot === "string") {
+            for (const item of asArray(slot)) {
+              new typesByName[typeDef.type](this, item);
+            }
+          } else {
+            for (const [objectName, objectData] of Object.entries(slot)) {
+              objectData.name = objectName;
+              new typesByName[typeDef.type](this, objectData);
+            }
           }
         } else {
-          this[typeDef.type] = new typesByName[typeDef.type](this, slot);
+         // if (typeDef.type) {
+            this[typeDef.type] = new typesByName[typeDef.type](this, slot);
+         // }
         }
       }
     }

package/src/cluster.mjs

@@ -6,8 +6,12 @@ export class Cluster extends Owner {
     addType(this);
   }
 
-  static get typeName() {
-    return "cluster";
+  static get typeDefinition() {
+    return {
+      name: "cluster",
+      extends: "owner",
+      properties: {}
+    };
   }
 
   constructor(owner, data) {

package/src/dns.mjs

@@ -14,9 +14,19 @@ export class DNSService extends Base {
   static {
     addType(this);
   }
-
-  static get typeName() {
-    return "dns";
+  
+  static get typeDefinition() {
+    return {
+      name: "dns",
+      properties: {
+        /*recordTTL: {},
+        soaUpdates: {},
+        hasSVRRecords: {},
+        hasCatalog: {},
+        forwardsTo: {},
+        allowedUpdates: {}*/
+      }
+    };
   }
 
   constructor(owner, data) {

package/src/host.mjs

@@ -27,14 +27,21 @@ export class Host extends Base {
     addType(this);
   }
 
-  static get typeName() {
-    return "host";
-  }
-
   static get typeDefinition() {
     return {
-      networkInterfaces: { type: "network_interface", collection: true },
-      services: { type: "service", collection: true }
+      name: "host",
+      extends: "base",
+      properties: {
+        networkInterfaces: { type: "network_interface", collection: true },
+        services: { type: "service", collection: true }
+        /*os: {},
+        distribution: {},
+        deployment: {},
+        master: { },
+        model: {},
+        replaces: { },
+        depends: {  }*/
+      }
     };
   }
 
@@ -299,8 +306,24 @@ export class NetworkInterface extends Base {
     addType(this);
   }
 
-  static get typeName() {
-    return "network_interface";
+  static get typeDefinition() {
+    return {
+      name: "network_interface",
+      extends: "base",
+      properties: {
+        /*
+        arpbridge: {},
+        hwaddr: {},
+        network: {},
+        gateway: {},
+        ssid: {},
+        psk: {},
+        scope: {},
+        metric: {},
+        kind: {},
+        ipAddresses: {}*/
+      }
+    };
   }
 
   #ipAddresses = new Map();

package/src/location.mjs

@@ -6,8 +6,18 @@ export class Location extends Owner {
     addType(this);
   }
 
-  static get typeName() {
-    return "location";
+  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: "dns", collection: false }
+      }
+    };
   }
 
   get location() {

package/src/network.mjs

@@ -1,5 +1,5 @@
 import { Owner } from "./owner.mjs";
-import { asArray } from "./utils.mjs";
+import { Subnet } from "./subnet.mjs";
 import { addType } from "./types.mjs";
 
 export class Network extends Owner {
@@ -13,18 +13,29 @@ export class Network extends Owner {
     addType(this);
   }
 
-  static get typeName() {
-    return "network";
+  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: "dns", collection: false }
+
+        /* kind: {},
+        scope: {},
+        metric: {},
+        bridge: {},
+        gateway: {}*/
+      }
+    };
   }
 
   constructor(owner, data) {
     super(owner, data);
 
-    if (data.subnets) {
-      this.addSubnets(data.subnets);
-      delete data.subnets;
-    }
-
     if (data.bridge) {
       this.bridge = owner.addBridge(this, data.bridge);
       delete data.bridge;
@@ -48,10 +59,10 @@ export class Network extends Owner {
     return super.networkNamed(name);
   }
 
-  addSubnets(value) {
-    for (const address of asArray(value)) {
-      const subnet = this.addSubnet(address);
-      subnet.networks.add(this);
+  addObject(object) {
+    super.addObject(object);
+    if (object instanceof Subnet) {
+      object.networks.add(this);
     }
   }
 
@@ -60,32 +71,6 @@ export class Network extends Owner {
   }
 
   set bridge(bridge) {
-    for (const network of bridge) {
-      if (network instanceof Network && network !== this) {
-        for (const subnet of this.subnets()) {
-          for (const otherSubnet of network.subnets()) {
-            if (
-              subnet !== otherSubnet &&
-              subnet.address === otherSubnet.address
-            ) {
-              /*console.log(
-                "SHARE SUBNETS",
-                subnet.owner.toString(),
-                otherSubnet.owner.toString()
-              );*/
-
-              otherSubnet.owner.addObject(subnet);
-              for (const n of otherSubnet.networks) {
-                subnet.networks.add(n);
-              }
-
-              //console.log(subnet.toString(),[...subnet.networks].map(n=>n.toString()));
-            }
-          }
-        }
-      }
-    }
-
     this.#bridge = bridge;
   }
 

package/src/owner.mjs

@@ -14,17 +14,17 @@ export class Owner extends Base {
     addType(this);
   }
 
-  static get typeName() {
-    return "owner";
-  }
-
   static get typeDefinition() {
     return {
-      networks: { type: "network", collection: true },
-      hosts: { type: "host", collection: true },
-      clusters: { type: "cluster", collection: true },
-      /*  subnets: { type: "subnet", collection: true },*/
-      dns: { type: "dns", collection: false }
+      name: "owner",
+      extends: "base",
+      properties: {
+        networks: { type: "network", collection: true },
+        hosts: { type: "host", collection: true },
+        clusters: { type: "cluster", collection: true },
+        subnets: { type: "subnet", collection: true },
+        dns: { type: "dns", collection: false }
+      }
     };
   }
 
@@ -66,7 +66,6 @@ export class Owner extends Base {
   }
 
   named(name) {
-    //console.log("NAMED", this.#membersByType.keys());
     for (const slot of this.#membersByType.values()) {
       const object = slot.get(name);
       if (object) {
@@ -164,13 +163,7 @@ export class Owner extends Base {
     const { cidr } = normalizeCIDR(address);
 
     if (cidr) {
-      let subnet = this.subnetNamed(cidr);
-
-      if (!subnet) {
-        subnet = new Subnet(this, { name: cidr });
-      }
-
-      return subnet;
+      return this.subnetNamed(cidr) || new Subnet(this, cidr);
     }
   }
 
@@ -229,7 +222,10 @@ export class Owner extends Base {
   _resolveBridges() {
     for (const bridge of this.#bridges) {
       //this.info(bridgeToJSON(bridge));
-      for (const network of bridge) {
+
+      const subnets = new Map();
+
+      for (let network of bridge) {
         if (typeof network === "string") {
           const other = this.networkNamed(network);
 
@@ -237,10 +233,25 @@ export class Owner extends Base {
             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);
+          }
+        }
       }
     }
   }

package/src/root.mjs

@@ -10,8 +10,13 @@ export class Root extends Location {
     addType(this);
   }
 
-  static get typeName() {
-    return "root";
+  static get typeDefinition() {
+    return {
+      name: "root",
+      extends: "location",
+      properties: {
+      }
+    };
   }
 
   constructor(directory) {

package/src/service.mjs

@@ -26,8 +26,22 @@ export class Service extends Base {
     addType(this);
   }
 
-  static get typeName() {
-    return "service";
+  static get typeDefinition() {
+    return {
+      name: "service",
+      extends: "base",
+      properties: {
+        /*ipAddresses: {},
+        addresses: {},
+        port: {},
+        protocol: {},
+        alias: {},
+        type: {},
+        master: {},
+        priority: {},
+        weight: {}*/
+      }
+    };
   }
 
   constructor(owner, data) {

package/src/subnet.mjs

@@ -9,24 +9,26 @@ export class Subnet extends Base {
     addType(this);
   }
 
-  static get typeName() {
-    return "subnet";
+  static get typeDefinition() {
+    return {
+      name: "subnet",
+      extends: "base",
+      properties: {
+        //  address: {}
+      }
+    };
   }
 
-  constructor(owner, data) {
-    const { cidr } = normalizeCIDR(data.name);
+  constructor(owner, address) {
+    const { cidr } = normalizeCIDR(address);
 
     if (!cidr) {
       const error = Error(`Invalid address`);
-      error.address = data.name;
+      error.address = address;
       throw error;
     }
 
-    data.name = cidr;
-
-    super(owner, data);
-
-    Object.assign(this, data);
+    super(owner, cidr);
 
     owner.addObject(this);
   }

package/src/types.mjs

@@ -1,6 +1,10 @@
 export function addType(clazz) {
   types.push(clazz);
-  typesByName[clazz.typeName] = clazz;
+
+  const typeDefinition = clazz.typeDefinition;
+  typeDefinition.clazz = clazz;
+
+  typesByName[typeDefinition.name] = clazz;
 }
 
 export const types = [];

package/types/base.d.mts

@@ -1,8 +1,10 @@
 export function extractFrom(object: any): {};
 export class Base {
     static get typeName(): string;
-    static get typeDefinition(): {};
-    static get pluralTypeName(): string;
+    static get typeDefinition(): {
+        name: string;
+        properties: {};
+    };
     static get nameLookupName(): string;
     static get typeFileName(): string;
     static get fileNameGlob(): string;

package/types/cluster.d.mts

@@ -1,4 +1,9 @@
 export class Cluster extends Owner {
+    static get typeDefinition(): {
+        name: string;
+        extends: string;
+        properties: {};
+    };
     constructor(owner: any, data: any);
 }
 import { Owner } from "./owner.mjs";

package/types/host.d.mts

@@ -1,12 +1,16 @@
 export class Host extends Base {
     static get typeDefinition(): {
-        networkInterfaces: {
-            type: string;
-            collection: boolean;
-        };
-        services: {
-            type: string;
-            collection: boolean;
+        name: string;
+        extends: string;
+        properties: {
+            networkInterfaces: {
+                type: string;
+                collection: boolean;
+            };
+            services: {
+                type: string;
+                collection: boolean;
+            };
         };
     };
     static prepareData(root: any, data: any): Promise<typeof Host>;
@@ -52,6 +56,11 @@ export class Host extends Base {
     #private;
 }
 export class NetworkInterface extends Base {
+    static get typeDefinition(): {
+        name: string;
+        extends: string;
+        properties: {};
+    };
     arpbridge: any;
     hwaddr: any;
     set network(networkOrName: any);

package/types/network.d.mts

@@ -7,7 +7,6 @@ export class Network extends Owner {
     set bridge(bridge: any);
     get bridge(): any;
     get network(): this;
-    addSubnets(value: any): void;
     #private;
 }
 import { Owner } from "./owner.mjs";

package/types/owner.d.mts

@@ -1,20 +1,28 @@
 export class Owner extends Base {
     static get typeDefinition(): {
-        networks: {
-            type: string;
-            collection: boolean;
-        };
-        hosts: {
-            type: string;
-            collection: boolean;
-        };
-        clusters: {
-            type: string;
-            collection: boolean;
-        };
-        dns: {
-            type: string;
-            collection: boolean;
+        name: string;
+        extends: string;
+        properties: {
+            networks: {
+                type: string;
+                collection: boolean;
+            };
+            hosts: {
+                type: string;
+                collection: boolean;
+            };
+            clusters: {
+                type: string;
+                collection: boolean;
+            };
+            subnets: {
+                type: string;
+                collection: boolean;
+            };
+            dns: {
+                type: string;
+                collection: boolean;
+            };
         };
     };
     constructor(owner: any, data?: {});

package/types/root.d.mts

@@ -1,4 +1,9 @@
 export class Root extends Location {
+    static get typeDefinition(): {
+        name: string;
+        extends: string;
+        properties: {};
+    };
     constructor(directory: any);
     get fullName(): string;
     get root(): this;

package/types/service.d.mts

@@ -1,4 +1,9 @@
 export class Service extends Base {
+    static get typeDefinition(): {
+        name: string;
+        extends: string;
+        properties: {};
+    };
     alias: any;
     get protocol(): any;
     get srvPrefix(): string;

package/types/subnet.d.mts

@@ -1,4 +1,9 @@
 export class Subnet extends Base {
+    static get typeDefinition(): {
+        name: string;
+        extends: string;
+        properties: {};
+    };
     networks: Set<any>;
     matchesAddress(address: any): any;
     get isLinkLocal(): any;