pmcf 1.42.2 → 1.43.1

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.2",
+  "version": "1.43.1",
   "publishConfig": {
     "access": "public"
   },

package/src/base.mjs

@@ -9,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";
   }
@@ -62,7 +64,7 @@ export class Base {
 
   read(data) {
     for (const [slotName, typeDef] of Object.entries(
-      this.constructor.typeDefinition
+      this.constructor.typeDefinition.properties
     )) {
       const slot = data[slotName];
       if (slot) {
@@ -79,7 +81,9 @@ export class Base {
             }
           }
         } 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();
@@ -379,7 +402,7 @@ export class NetworkInterface extends Base {
   subnetForAddress(address) {
     return (
       this.network?.subnetForAddress(address) ||
-      this.owner.owner.subnetForAddress(address)
+      this.host.owner.subnetForAddress(address)
     );
   }
 
@@ -404,8 +427,8 @@ export class NetworkInterface extends Base {
   }
 
   get ipAddressesWithPrefixLength() {
-    return [...this.ipAddresses].map(address =>
-      this.addressWithPrefixLength(address)
+    return [...this.#ipAddresses].map(
+      ([address, subnet]) => `${address}/${subnet?.prefixLength}`
     );
   }
 
@@ -417,10 +440,6 @@ export class NetworkInterface extends Base {
     return [...this.ipAddresses].filter(a => isIPv6Address(a));
   }
 
-  get prefixLength() {
-    return this.network?.prefixLength;
-  }
-
   get host() {
     return this.owner;
   }

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

@@ -13,8 +13,24 @@ 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) {

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 }
+      }
     };
   }
 
@@ -165,6 +165,16 @@ export class Owner extends Base {
     if (cidr) {
       return this.subnetNamed(cidr) || new Subnet(this, cidr);
     }
+
+    const subnets = [...this.subnets()];
+    if (subnets.length === 1) {
+      return subnets[0];
+    }
+
+    this.error(
+      `Address without subnet ${address}`,
+      [...this.subnets()].map(s => s.address)
+    );
   }
 
   subnetForAddress(address) {

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,8 +9,18 @@ export class Subnet extends Base {
     addType(this);
   }
 
-  static get typeName() {
-    return "subnet";
+  static get typeDefinition() {
+    return {
+      name: "subnet",
+      extends: "base",
+      properties: {
+        /*
+        address: {},
+        networks: { type: "network", collection true },
+        prefixLength: { type: "number", writeable: false }
+        */
+      }
+    };
   }
 
   constructor(owner, address) {

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/src/utils.mjs

@@ -137,15 +137,23 @@ export function normalizeCIDR(address) {
     prefix = "fe80::";
     prefixLength = 64;
   } else {
+    const definition = isIPv4Address(prefix) ? ipv4 : ipv6;
+    let n = _encode(definition, prefix);
+
     if (prefixLength) {
-      const definition = isIPv4Address(prefix) ? ipv4 : ipv6;
-      let n = _encode(definition, prefix);
       n = n & (definition.mask << BigInt(definition.length - prefixLength));
       prefix = _decode(definition, n, prefixLength);
     } else {
-      return {};
+      if (n === IPV4_LOCALHOST) {
+        prefixLength = 8;
+        prefix = _decode(definition, n, prefixLength);
+      } else {
+        return {};
+      }
     }
   }
 
   return { prefix, prefixLength, cidr: `${prefix}/${prefixLength}` };
 }
+
+const IPV4_LOCALHOST = _encode(ipv4,'127.0.0.1')

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);
@@ -66,7 +75,6 @@ export class NetworkInterface extends Base {
     get ipAddressesWithPrefixLength(): string[];
     get ipv4Addresses(): any[];
     get ipv6Addresses(): any[];
-    get prefixLength(): any;
     get scope(): any;
     get metric(): any;
     get ssid(): any;

package/types/owner.d.mts

@@ -1,24 +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;
-        };
-        subnets: {
-            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;