pmcf 1.42.2 → 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.2",
+  "version": "1.43.0",
   "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();

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 }
+      }
     };
   }
 

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,14 @@ export class Subnet extends Base {
     addType(this);
   }
 
-  static get typeName() {
-    return "subnet";
+  static get typeDefinition() {
+    return {
+      name: "subnet",
+      extends: "base",
+      properties: {
+        //  address: {}
+      }
+    };
   }
 
   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/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/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;