pmcf 1.46.3 → 1.47.0

package/src/owner.mjs

@@ -4,53 +4,47 @@ import { Subnet } from "./subnet.mjs";
 import { addType } from "./types.mjs";
 import { DNSService } from "./dns.mjs";
 
+const OwnerTypeDefinition = {
+  name: "owner",
+  owners: ["owner", "root"],
+  priority: 0.9,
+  extends: Base.typeDefinition,
+  properties: {
+    networks: { type: "network", collection: true, writeable: true },
+    hosts: { type: "host", collection: true, writeable: true },
+    clusters: { type: "cluster", collection: true, writeable: true },
+    subnets: { type: Subnet.typeDefinition, collection: true, writeable: true },
+    dns: {
+      type: DNSService.typeDefinition,
+      collection: false,
+      writeable: true
+    },
+    ntp: { type: "string", collection: false, writeable: true },
+    domain: { type: "string", collection: false, writeable: true },
+    administratorEmail: { type: "string", collection: false, writeable: true }
+  }
+};
+
+const EMPTY = new Map();
+
 export class Owner extends Base {
   #membersByType = new Map();
   #bridges = new Set();
   #administratorEmail;
   domain;
-  ntp = { servers: [] };
+  ntp;
 
   static {
     addType(this);
   }
 
   static get typeDefinition() {
-    return {
-      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: DNSService, collection: false },
-        domain: { type: "string" },
-        administratorEmail: { type: "string" }
-      }
-    };
+    return OwnerTypeDefinition;
   }
 
-  constructor(owner, data = {}) {
+  constructor(owner, data) {
     super(owner, data);
-
-    if (data.administratorEmail) {
-      this.#administratorEmail = data.administratorEmail;
-      delete data.administratorEmail;
-    }
-
-    if (data.domain) {
-      this.domain = data.domain;
-      delete data.domain;
-    }
-
-    if (data.ntp) {
-      this.ntp = data.ntp;
-      delete data.ntp;
-    }
-
-    this.read(data);
-
+    this.read(data, OwnerTypeDefinition);
     owner?.addObject(this);
   }
 
@@ -62,6 +56,8 @@ export class Owner extends Base {
         }
       }
 
+      this.dns?._traverse(...args);
+
       return true;
     }
 
@@ -69,6 +65,10 @@ export class Owner extends Base {
   }
 
   named(name) {
+    if (name[0] === "/") {
+      name = name.substring(this.fullName.length + 1);
+    }
+
     for (const slot of this.#membersByType.values()) {
       const object = slot.get(name);
       if (object) {
@@ -78,6 +78,10 @@ export class Owner extends Base {
   }
 
   typeNamed(typeName, name) {
+    if (name[0] === "/") {
+      name = name.substring(this.fullName.length + 1);
+    }
+
     const typeSlot = this.#membersByType.get(typeName);
     return typeSlot?.get(name) || this.owner?.typeNamed(typeName, name);
   }
@@ -88,29 +92,26 @@ export class Owner extends Base {
 
   typeList(typeName) {
     const typeSlot = this.#membersByType.get(typeName);
-    if (typeSlot) {
-      return typeSlot.values();
-    }
-
-    return [];
+    return (typeSlot || EMPTY).values();
   }
 
-  _addObject(typeName, fullName, object) {
+  addTypeObject(typeName, name, object) {
     let typeSlot = this.#membersByType.get(typeName);
     if (!typeSlot) {
       typeSlot = new Map();
       this.#membersByType.set(typeName, typeSlot);
     }
-    typeSlot.set(fullName, object);
+
+    typeSlot.set(name, object);
   }
 
   addObject(object) {
-    this._addObject(object.typeName, object.fullName, object);
+    this.addTypeObject(object.typeName, object.name, object);
   }
 
-  service(filter) {
+  findService(filter) {
     let best;
-    for (const service of this.services(filter)) {
+    for (const service of this.findServices(filter)) {
       if (!best || service.priority < best.priority) {
         best = service;
       }
@@ -119,9 +120,9 @@ export class Owner extends Base {
     return best;
   }
 
-  *services(filter) {
+  *findServices(filter) {
     for (const host of this.hosts()) {
-      for (const service of host.services(filter)) {
+      for (const service of host.findServices(filter)) {
         yield service;
       }
     }
@@ -169,17 +170,14 @@ export class Owner extends Base {
       return this.subnetNamed(cidr) || new Subnet(this, cidr);
     }
 
-    const subnets = [...this.subnets()];
-
-    const subnet = subnets.find(s => s.matchesAddress(address));
-    if (subnet) {
-      return subnet;
+    const subnet = this.subnetForAddress(address);
+    if (!subnet) {
+      this.error(
+        `Address without subnet ${address}`,
+        [...this.subnets()].map(s => s.address)
+      );
     }
-
-    this.error(
-      `Address without subnet ${address}`,
-      [...this.subnets()].map(s => s.address)
-    );
+    return subnet;
   }
 
   subnetForAddress(address) {
@@ -236,8 +234,6 @@ export class Owner extends Base {
 
   _resolveBridges() {
     for (const bridge of this.#bridges) {
-      //this.info(bridgeToJSON(bridge));
-
       const subnets = new Map();
 
       for (let network of bridge) {
@@ -253,7 +249,6 @@ export class Owner extends Base {
             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);
@@ -277,8 +272,20 @@ export class Owner extends Base {
     }
   }
 
+  set administratorEmail(value) {
+    this.#administratorEmail = value;
+  }
+
   get administratorEmail() {
-    return this.#administratorEmail || "admin@" + this.domain;
+    if (this.#administratorEmail) {
+      return this.#administratorEmail;
+    }
+
+    if (this.owner) {
+      return this.owner.administratorEmail;
+    }
+
+    return "admin@" + this.domain;
   }
 
   *domains() {
@@ -286,14 +293,4 @@ export class Owner extends Base {
       yield location.domain;
     }
   }
-
-  toJSON() {
-    const json = super.toJSON();
-
-    for (const [typeName, slot] of this.#membersByType) {
-      json[typeName] = [...slot.keys()].sort();
-    }
-
-    return json;
-  }
 }

package/src/root.mjs

@@ -1,8 +1,15 @@
 import { readFile, glob } from "node:fs/promises";
 import { join } from "node:path";
-import { Base } from "./base.mjs";
 import { Location } from "./location.mjs";
-import { addType, types } from "./types.mjs";
+import { addType, types, resolveTypeLinks } from "./types.mjs";
+
+const RootTypeDefinition = {
+  name: "root",
+  owners: [],
+  priority: 1000,
+  extends: Location.typeDefinition,
+  properties: {}
+};
 
 export class Root extends Location {
   static {
@@ -10,15 +17,12 @@ export class Root extends Location {
   }
 
   static get typeDefinition() {
-    return {
-      name: "root",
-      extends: Location,
-      properties: {}
-    };
+    return RootTypeDefinition;
   }
 
   constructor(directory) {
-    super(undefined, { name: "" });
+    resolveTypeLinks();
+    super(undefined, "");
     this.directory = directory;
     this.addObject(this);
   }
@@ -31,63 +35,53 @@ export class Root extends Location {
     return this;
   }
 
+  async _load(name, type) {
+    const data = JSON.parse(
+      await readFile(
+        join(this.directory, name, type.clazz.typeFileName),
+        "utf8"
+      )
+    );
+
+    const parentName = name.replace(/\/[^\/]+$/, "");
+    const owner = name === parentName ? this.root : await this.load(parentName);
+
+    const fullName = this.fullName + "/" + name;
+    data.name = fullName.substring(owner.fullName.length + 1);
+
+    const object = new type.clazz(owner, data);
+
+    this.addTypeObject(type.clazz.typeName, name, object);
+    return object;
+  }
+
   async load(name, options) {
-    const fullName = Base.normalizeName(name);
-    let object = this.named(fullName);
+    name = name.replace(/\/([^\/]+\.json)?$/, "");
+
+    const object = this.named(name);
     if (object) {
       return object;
     }
 
-    //console.log("LOAD", fullName);
-
-    let path = fullName.split("/");
-    path.pop();
-
-    let data;
-    let type = options?.type;
-    if (type) {
-      data = JSON.parse(
-        await readFile(
-          join(this.directory, fullName, type.typeFileName),
-          "utf8"
-        )
-      );
+    if (options?.type) {
+      return this._load(name, options.type);
     } else {
-      for (type of types) {
+      for (const type of Object.values(types)) {
         try {
-          data = JSON.parse(
-            await readFile(
-              join(this.directory, fullName, type.typeFileName),
-              "utf8"
-            )
-          );
-          break;
+          return await this._load(name, type);
         } catch {}
       }
-
-      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);
-
-    return object;
+    const parentName = name.replace(/\/[^\/]$/, "");
+    return name === parentName ? this.root : this.load(parentName, options);
   }
 
   async loadAll() {
-    for (let type of types) {
-      for await (const name of glob(type.fileNameGlob, {
+    for (const type of Object.values(types).sort(
+      (a, b) => b.priority - a.priority
+    )) {
+      for await (const name of glob(type.clazz.fileNameGlob, {
         cwd: this.directory
       })) {
         await this.load(name, { type });

package/src/service.mjs

@@ -14,6 +14,24 @@ const ServiceTypes = {
   dhcp: {}
 };
 
+const ServiceTypeDefinition = {
+  name: "service",
+  owners: ["host"],
+  priority: 0.4,
+  extends: Base.typeDefinition,
+  properties: {
+    ipAddresses: { type: "string", collection: true, writeable: true },
+    addresses: { type: "string", collection: true, writeable: true },
+    port: { type: "number", collection: false, writeable: true },
+    protocol: { type: "string", collection: false, writeable: true },
+    alias: { type: "string", collection: false, writeable: true },
+    type: { type: "string", collection: false, writeable: true },
+    master: { type: "boolean", collection: false, writeable: true },
+    priority: { type: "number", collection: false, writeable: true },
+    weight: { type: "number", collection: false, writeable: true }
+  }
+};
+
 export class Service extends Base {
   alias;
   #weight;
@@ -27,49 +45,13 @@ export class Service extends Base {
   }
 
   static get typeDefinition() {
-    return {
-      name: "service",
-      extends: Base,
-      properties: {
-        ipAddresses: { type: "string", collection: true },
-        addresses: { type: "string", collection: true },
-        port: { type: "number" },
-        protocol: { type: "string" },
-        alias: { type: "string" },
-        type: { type: "string" },
-        master: { type: "boolean" },
-        priority: { type: "number" },
-        weight: { type: "number" }
-      }
-    };
+    return ServiceTypeDefinition;
   }
 
   constructor(owner, data) {
     super(owner, data);
-    if (data.weight !== undefined) {
-      this.#weight = data.weight;
-      delete data.weight;
-    }
-    if (data.priority !== undefined) {
-      this.#priority = data.priority;
-      delete data.priority;
-    }
-    if (data.type) {
-      this.#type = data.type;
-      delete data.type;
-    }
-    if (data.port !== undefined) {
-      this.#port = data.port;
-      delete data.port;
-    }
-    if (data.ipAddresses) {
-      this.#ipAddresses = data.ipAddresses;
-      delete data.ipAddresses;
-    }
-
-    Object.assign(this, data);
-
-    owner.addService(this);
+    this.read(data, ServiceTypeDefinition);
+  // owner.addService(this);
   }
 
   forOwner(owner) {
@@ -90,6 +72,7 @@ export class Service extends Base {
       if (this.#ipAddresses) {
         data.ipAddresses = this.#ipAddresses;
       }
+
       // @ts-ignore
       return new this.constructor(owner, data);
     }
@@ -97,15 +80,8 @@ export class Service extends Base {
     return this;
   }
 
-  get protocol() {
-    return ServiceTypes[this.type]?.protocol;
-  }
-
-  get srvPrefix() {
-    const st = ServiceTypes[this.type];
-    if (st?.protocol) {
-      return `_${this.type}._${st.protocol}`;
-    }
+  set ipAddresses(value) {
+    this.#ipAddresses = value;
   }
 
   get ipAddresses() {
@@ -116,23 +92,50 @@ export class Service extends Base {
     return this.ipAddresses.map(a => `${a}:${this.port}`);
   }
 
+  set port(value) {
+    this.#port = value;
+  }
+
   get port() {
     return this.#port || ServiceTypes[this.type]?.port;
   }
 
+  set priority(value) {
+    this.#priority = value;
+  }
+
   get priority() {
     return this.#priority || this.owner.priority || 99;
   }
 
+  set weight(value) {
+    this.#weight = value;
+  }
+
   get weight() {
     return this.#weight || this.owner.weight || 0;
   }
 
-  get master() {
-    return this.owner.master;
+  set type(value) {
+    this.#type = value;
   }
 
   get type() {
     return this.#type || this.name;
   }
+
+  get master() {
+    return this.owner.master;
+  }
+
+  get protocol() {
+    return ServiceTypes[this.type]?.protocol;
+  }
+
+  get srvPrefix() {
+    const st = ServiceTypes[this.type];
+    if (st?.protocol) {
+      return `_${this.type}._${st.protocol}`;
+    }
+  }
 }

package/src/subnet.mjs

@@ -2,6 +2,23 @@ import { normalizeCIDR, isLinkLocal } from "./utils.mjs";
 import { Base } from "./base.mjs";
 import { addType } from "./types.mjs";
 
+const SubnetTypeDefinition = {
+  name: "subnet",
+  owners: ["location", "owner", "network", "root"],
+  priority: 0.6,
+  constructWithIdentifierOnly: true,
+  properties: {
+    address: {
+      type: "string",
+      collection: false,
+      writeable: false,
+      identifier: true
+    },
+    networks: { type: "network", collection: true, writeable: true },
+    prefixLength: { type: "number", collection: false, writeable: false }
+  }
+};
+
 export class Subnet extends Base {
   networks = new Set();
 
@@ -10,27 +27,12 @@ export class Subnet extends Base {
   }
 
   static get typeDefinition() {
-    return {
-      name: "subnet",
-      properties: {
-        address: { type: "string" },
-        networks: { type: "network", collection: true },
-        prefixLength: { type: "number", writeable: false }
-      }
-    };
+    return SubnetTypeDefinition;
   }
 
   constructor(owner, address) {
     const { cidr } = normalizeCIDR(address);
-
-    if (!cidr) {
-      const error = Error(`Invalid address`);
-      error.address = address;
-      throw error;
-    }
-
     super(owner, cidr);
-
     owner.addObject(this);
   }
 

package/src/types.mjs

@@ -1,24 +1,50 @@
+export const types = {};
+
 export function addType(clazz) {
-  types.push(clazz);
+  const type = clazz.typeDefinition;
+
+  types[type.name] = type;
+
+  type.clazz = clazz;
+}
+
+export const primitives = new Set(["string", "number", "boolean"]);
 
-  const typeDefinition = clazz.typeDefinition;
-  typeDefinition.clazz = clazz;
+export function resolveTypeLinks() {
+  for (const type of Object.values(types)) {
+    type.owners = type.owners.map(owner =>
+      typeof owner === "string" ? types[owner] : owner
+    );
 
-  typesByName[typeDefinition.name] = clazz;
+    for (const [name, property] of Object.entries(type.properties)) {
+      property.name = name;
+      if (property.identifier) {
+        type.identifier = property;
+      }
 
-  for (const type of types) {
-    for (const [name, property] of Object.entries(
-      type.typeDefinition.properties
-    )) {
       if (typeof property.type === "string") {
-        const t = typesByName[property.type];
-        if (t) {
-          property.type = t;
+        if (!primitives.has(property.type)) {
+          const type = types[property.type];
+          if (type) {
+            property.type = type;
+          } else {
+            console.error(
+              "Unknown type",
+              property.type,
+              type.name,
+              property.name
+            );
+          }
         }
       }
     }
   }
-}
 
-export const types = [];
-export const typesByName = {};
+  for (const type of Object.values(types)) {
+    if (!type.identifier) {
+      if (type.extends?.identifier) {
+        type.identifier = type.extends.identifier;
+      }
+    }
+  }
+}

package/types/base.d.mts

@@ -1,37 +1,51 @@
-export function extractFrom(object: any, typeDefinition: any): any;
+export function extractFrom(object: any, typeDefinition?: any): any;
 export class Base {
     static get typeName(): string;
     static get typeDefinition(): {
         name: string;
+        owners: any[];
         properties: {
+            owner: {
+                type: string;
+                collection: boolean;
+                writeable: boolean;
+            };
             type: {
                 type: string;
+                collection: boolean;
                 writeable: boolean;
             };
             name: {
                 type: string;
+                collection: boolean;
+                identifier: boolean;
+                writeable: boolean;
             };
             description: {
                 type: string;
+                collection: boolean;
+                writeable: boolean;
             };
             directory: {
                 type: string;
+                collection: boolean;
                 writeable: boolean;
             };
-            owner: {};
         };
     };
-    static get nameLookupName(): string;
     static get typeFileName(): string;
     static get fileNameGlob(): string;
-    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;
-    read(data: any): void;
+    name: string;
+    ownerFor(property: any, data: any): any;
+    read(data: any, type: any): void;
+    typeNamed(typeName: any, name: any): any;
+    addObject(object: any): any;
     forOwner(owner: any): any;
+    isNamed(name: any): boolean;
+    relativeName(name: any): any;
     get typeName(): any;
     get root(): any;
     get location(): any;