pmcf 2.29.2 → 2.30.0

package/README.md

@@ -14,7 +14,6 @@
 
 ## Poor mans configuration management
 
-
 # API
 
 <!-- Generated by documentation.js. Update this documentation by updating the source code. -->

package/package.json

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

package/src/base.mjs

@@ -190,7 +190,7 @@ export class Base {
             assign(property, value);
           } else {
             const factory =
-              property.type.factoryFor?.(value) || property.type.clazz;
+              property.type.factoryFor?.(this,value) || property.type.clazz;
 
             assign(
               property,

package/src/host-utils.mjs

@@ -1,8 +1,5 @@
-import { writeFile, mkdir } from "node:fs/promises";
 import { join } from "node:path";
-import { writeLines, sectionLines } from "../src/utils.mjs";
-import { addHook } from "./hooks.mjs";
-import { cidrAddresses } from "./network-support.mjs";
+import { writeLines } from "../src/utils.mjs";
 
 export async function generateMachineInfo(host, packageData) {
   const etcDir = join(packageData.dir, "etc");
@@ -22,115 +19,6 @@ export async function generateMachineInfo(host, packageData) {
   await writeLines(etcDir, "hostname", host.hostName);
 }
 
-export async function generateNetworkDefs(host, packageData) {
-  const networkDir = join(packageData.dir, "etc/systemd/network");
-
-  for (const ni of host.networkInterfaces.values()) {
-    await ni.systemdDefinitions(packageData);
-
-    switch (ni.kind) {
-      case "loopback":
-        continue;
-    }
-
-    if (ni.name !== "eth0" && ni.hwaddr) {
-      await writeLines(networkDir, `${ni.name}.link`, [
-        sectionLines("Match", { MACAddress: ni.hwaddr }),
-        "",
-        sectionLines("Link", { Name: ni.name })
-      ]);
-    }
-
-    const networkSections = [sectionLines("Match", { Name: ni.name })];
-
-    for (const Address of cidrAddresses(ni.networkAddresses())) {
-      networkSections.push(
-        "",
-        sectionLines("Address", {
-          Address
-        })
-      );
-    }
-
-    switch (ni.kind) {
-      case "ethernet":
-      case "wlan":
-        const routeSectionExtra = ni.destination
-          ? { Destination: ni.destination }
-          : { Gateway: ni.gatewayAddress };
-
-        const networkSectionExtra = ni.arpbridge
-          ? {
-              IPForward: "yes",
-              IPv4ProxyARP: "yes"
-            }
-          : {};
-
-        networkSections.push(
-          "",
-          sectionLines("Network", {
-            ...networkSectionExtra,
-            DHCP: "no",
-            DHCPServer: "no",
-            MulticastDNS: ni.network.multicastDNS ? "yes" : "no",
-            LinkLocalAddressing: "ipv6",
-            IPv6LinkLocalAddressGenerationMode: "stable-privacy"
-          }),
-          "",
-          sectionLines("Route", {
-            ...routeSectionExtra,
-            Scope: ni.scope,
-            Metric: ni.metric,
-            InitialCongestionWindow: 20,
-            InitialAdvertisedReceiveWindow: 20
-          }),
-          "",
-          sectionLines("IPv6AcceptRA", {
-            UseAutonomousPrefix: "true",
-            UseOnLinkPrefix: "true",
-            DHCPv6Client: "false",
-            Token: "eui64"
-          })
-        );
-
-        if (ni.arpbridge) {
-          networkSections.push(
-            "",
-            sectionLines("Link", { Promiscuous: "yes" })
-          );
-        }
-    }
-
-    await writeLines(networkDir, `${ni.name}.network`, networkSections);
-
-    switch (ni.kind) {
-      case "wifi": {
-        const d = join(packageData.dir, "etc/wpa_supplicant");
-        await mkdir(d, { recursive: true });
-        writeFile(
-          join(d, `wpa_supplicant-${ni.name}.conf`),
-          `country=${host.location.country}
-ctrl_interface=DIR=/run/wpa_supplicant GROUP=netdev
-update_config=1
-p2p_disabled=1
-network={
-  ssid="${ni.ssid}"
-  psk=${ni.psk}
-  scan_ssid=1
-}`,
-          "utf8"
-        );
-
-        addHook(
-          packageData.properties.hooks,
-          "post_install",
-          `systemctl enable wpa_supplicant@${ni.name}.service`
-        );
-      }
-    }
-  }
-}
-
 export async function generateKnownHosts(hosts, dir) {
   const keys = [];
   for await (const host of hosts) {

package/src/host.mjs

@@ -7,12 +7,8 @@ import { domainFromDominName, domainName } from "./utils.mjs";
 import { objectFilter } from "./filter.mjs";
 import { addType, types } from "./types.mjs";
 import { loadHooks } from "./hooks.mjs";
-import {
-  generateNetworkDefs,
-  generateMachineInfo,
-  generateKnownHosts
-} from "./host-utils.mjs";
-import { NetworkInterfaceTypeDefinition } from "./network-interface.mjs";
+import { generateMachineInfo, generateKnownHosts } from "./host-utils.mjs";
+import { NetworkInterfaceTypeDefinition } from "./network-interfaces/network-interface.mjs";
 
 const HostTypeDefinition = {
   name: "host",
@@ -45,12 +41,17 @@ const HostTypeDefinition = {
     weight: { type: "number", collection: false, writeable: true },
     serial: { type: "string", collection: false, writeable: true },
     vendor: { type: "string", collection: false, writeable: true },
-    chassis: { type: "string", collection: false, writeable: true },
+    chassis: {
+      type: "string",
+      collection: false,
+      writeable: true,
+      values: ["phone", "tablet", "router", "desktop", "server"]
+    },
     architecture: {
       type: "string",
       collection: false,
       writeable: true,
-      values: ["x86", "aarch64", "armv7"]
+      values: ["x86", "x86_64", "aarch64", "armv7"]
     },
     replaces: { type: "string", collection: true, writeable: true },
     depends: { type: "string", collection: true, writeable: true },
@@ -483,7 +484,10 @@ export class Host extends Base {
       }
     };
 
-    await generateNetworkDefs(this, packageData);
+    for (const ni of this.networkInterfaces.values()) {
+      await ni.systemdDefinitions(packageData);
+    }
+
     await generateMachineInfo(this, packageData);
     await generateKnownHosts(this.owner.hosts(), join(dir, "root", ".ssh"));
 

package/src/module.mjs

@@ -8,7 +8,11 @@ export * from "./subnet.mjs";
 export * from "./network.mjs";
 export * from "./network-address.mjs";
 export * from "./network-support.mjs";
-export * from "./network-interface.mjs";
+export * from "./network-interfaces/network-interface.mjs";
+export * from "./network-interfaces/loopback.mjs";
+export * from "./network-interfaces/ethernet.mjs";
+export * from "./network-interfaces/wlan.mjs";
+export * from "./network-interfaces/wireguard.mjs";
 export * from "./host.mjs";
 export * from "./service.mjs";
 export * from "./endpoint.mjs";

package/src/network-address.mjs

@@ -2,11 +2,7 @@ import { familyIP, formatCIDR } from "ip-utilties";
 import { Subnet } from "./subnet.mjs";
 
 /**
- * @property {NetworkInterface} networkInterface
- * @property {string|Uint8Array|Uint16Array} address
- * @property {string} family
- * @property {Subnet} subnet
- * @property {Set<string>} domainNames
+ * 
  */
 export class NetworkAddress {
   /** @type {Subnet} */ subnet;

package/src/network-interfaces/ethernet.mjs

@@ -0,0 +1,37 @@
+import { addType } from "../types.mjs";
+import {
+  NetworkInterface,
+  NetworkInterfaceTypeDefinition
+} from "./network-interface.mjs";
+
+export const EthernetNetworkInterfaceTypeDefinition = {
+  name: "ethernet",
+  specializationOf: NetworkInterfaceTypeDefinition,
+  owners: NetworkInterfaceTypeDefinition.owners,
+  extends: NetworkInterfaceTypeDefinition,
+  priority: 0.1,
+  properties: {
+    arpbridge: { type: "network_interface", collection: true, writeable: true }
+  }
+};
+
+export class EthernetNetworkInterface extends NetworkInterface {
+  arpbridge;
+
+  static {
+    addType(this);
+  }
+
+  static get typeDefinition() {
+    return EthernetNetworkInterfaceTypeDefinition;
+  }
+
+  constructor(owner, data) {
+    super(owner, data);
+    this.read(data, EthernetNetworkInterfaceTypeDefinition);
+  }
+
+  get kind() {
+    return EthernetNetworkInterfaceTypeDefinition.name;
+  }
+}

package/src/network-interfaces/loopback.mjs

@@ -0,0 +1,44 @@
+import { SUBNET_LOCALHOST_IPV4, SUBNET_LOCALHOST_IPV6 } from "pmcf";
+import { SkeletonNetworkInterface } from "./skeleton.mjs";
+import { NetworkInterfaceTypeDefinition } from "./network-interface.mjs";
+import { addType } from "../types.mjs";
+
+const LoopbackNetworkInterfaceTypeDefinition = {
+  name: "loopback",
+  specializationOf: NetworkInterfaceTypeDefinition,
+  owners: NetworkInterfaceTypeDefinition.owners,
+  extends: NetworkInterfaceTypeDefinition,
+  priority: 0.1,
+  properties: {}
+};
+
+const _localAddresses = new Map([
+  ["127.0.0.1", SUBNET_LOCALHOST_IPV4],
+  ["::1", SUBNET_LOCALHOST_IPV6]
+]);
+
+export class LoopbackNetworkInterface extends SkeletonNetworkInterface {
+  static {
+    addType(this);
+  }
+
+  static get typeDefinition() {
+    return LoopbackNetworkInterfaceTypeDefinition;
+  }
+
+  get kind() {
+    return LoopbackNetworkInterfaceTypeDefinition.name;
+  }
+
+  get scope() {
+    return "host";
+  }
+
+  get hostName() {
+    return "localhost";
+  }
+
+  get ipAddresses() {
+    return _localAddresses;
+  }
+}

package/src/network-interfaces/network-interface.mjs

@@ -0,0 +1,245 @@
+import { join } from "node:path";
+import { hasWellKnownSubnet, normalizeIP } from "ip-utilties";
+import { Base } from "pmcf";
+import {
+  networkProperties,
+  networkAddressProperties
+} from "../network-support.mjs";
+import { asArray, writeLines, sectionLines } from "../utils.mjs";
+import { addType } from "../types.mjs";
+import { cidrAddresses } from "../network-support.mjs";
+import { SkeletonNetworkInterface } from "./skeleton.mjs";
+
+export const NetworkInterfaceTypeDefinition = {
+  name: "network_interface",
+  priority: 0.4,
+  owners: ["host"],
+  extends: Base.typeDefinition,
+  specializations: {},
+  factoryFor(owner, value) {
+    const kind = value.kind;
+    const t = NetworkInterfaceTypeDefinition.specializations[kind];
+
+    if (!t) {
+      console.warn("FACTORY", owner.name, value, t?.name);
+    }
+    if (t) {
+      delete value.type;
+      delete value.kind;
+      return t.clazz;
+    }
+
+    return NetworkInterface;
+  },
+  properties: {
+    ...networkProperties,
+    ...networkAddressProperties,
+    hostName: { type: "string", collection: false, writeable: true },
+    ipAddresses: { type: "string", collection: true, writeable: true },
+
+    hwaddr: { type: "string", collection: false, writeable: true },
+    network: { type: "network", collection: false, writeable: true },
+    destination: { type: "string", collection: false, writeable: true }
+  }
+};
+
+export class NetworkInterface extends SkeletonNetworkInterface {
+  static {
+    addType(this);
+  }
+
+  static get typeDefinition() {
+    return NetworkInterfaceTypeDefinition;
+  }
+
+  _ipAddresses = new Map();
+  _scope;
+  _metric;
+  _kind;
+  _hostName;
+  _hwaddr;
+  _class;
+
+  constructor(owner, data) {
+    super(owner, data);
+    this.read(data, NetworkInterfaceTypeDefinition);
+  }
+
+  addSubnet(address) {
+    if (!this.network) {
+      if (!hasWellKnownSubnet(address)) {
+        this.error("Missing network", address);
+      }
+    } else {
+      return this.network.addSubnet(address);
+    }
+  }
+
+  get ipAddresses() {
+    return this._ipAddresses;
+  }
+
+  set ipAddresses(value) {
+    for (const address of asArray(value)) {
+      this._ipAddresses.set(normalizeIP(address), this.addSubnet(address));
+    }
+  }
+
+  subnetForAddress(address) {
+    return (
+      this.network?.subnetForAddress(address) ||
+      this.host.owner.subnetForAddress(address)
+    );
+  }
+
+  get gateway() {
+    return this.network?.gateway;
+  }
+
+  get gatewayAddress() {
+    for (const a of this.gateway.networkAddresses()) {
+      if (a.networkInterface.network === this.network) {
+        return a.address;
+      }
+    }
+  }
+
+  get hostName() {
+    return this.extendedProperty("_hostName") ?? this.host.hostName;
+  }
+
+  set hostName(value) {
+    this._hostName = value;
+  }
+
+  get domainNames() {
+    return this.hostName
+      ? new Set([[this.hostName, this.host.domain].join(".")])
+      : this.host.directDomainNames;
+  }
+
+  set scope(value) {
+    this._scope = value;
+  }
+
+  get scope() {
+    return (
+      this.extendedProperty("_scope") ??
+      this.network?.scope ??
+      networkProperties.scope.default
+    );
+  }
+
+  set hwaddr(value) {
+    this._hwaddr = value;
+  }
+
+  get hwaddr() {
+    return this.extendedProperty("_hwaddr");
+  }
+
+  set metric(value) {
+    this._metric = value;
+  }
+
+  get metric() {
+    return (
+      this.extendedProperty("_metric") ??
+      this.network?.metric ??
+      networkProperties.metric.default
+    );
+  }
+
+  set MTU(value) {
+    this._MTU = value;
+  }
+
+  get MTU() {
+    return this.extendedProperty("_MTU") ?? networkProperties.MTU.default;
+  }
+
+  set class(value) {
+    this._class = value;
+  }
+
+  get class() {
+    return this.extendedProperty("_class") ?? this.network?.class;
+  }
+
+  set kind(value) {
+    this._kind = value;
+  }
+
+  get kind() {
+    return this.extendedProperty("_kind") ?? this.network?.kind;
+  }
+
+  async systemdDefinitions(packageData) {
+    await super.systemdDefinitions(packageData);
+
+    const networkDir = join(packageData.dir, "etc/systemd/network");
+
+    if (this.name !== "eth0" && this.hwaddr) {
+      await writeLines(networkDir, `${this.name}.link`, [
+        sectionLines("Match", { MACAddress: this.hwaddr }),
+        "",
+        sectionLines("Link", { Name: this.name })
+      ]);
+    }
+
+    const networkSections = [sectionLines("Match", { Name: this.name })];
+
+    for (const Address of cidrAddresses(this.networkAddresses())) {
+      networkSections.push(
+        "",
+        sectionLines("Address", {
+          Address
+        })
+      );
+    }
+
+    const routeSectionExtra = this.destination
+      ? { Destination: this.destination }
+      : { Gateway: this.gatewayAddress };
+
+    const networkSectionExtra = this.arpbridge
+      ? {
+          IPForward: "yes",
+          IPv4ProxyARP: "yes"
+        }
+      : {};
+
+    networkSections.push(
+      "",
+      sectionLines("Network", {
+        ...networkSectionExtra,
+        DHCP: "no",
+        DHCPServer: "no",
+        MulticastDNS: this.network.multicastDNS ? "yes" : "no",
+        LinkLocalAddressing: "ipv6",
+        IPv6LinkLocalAddressGenerationMode: "stable-privacy"
+      }),
+      "",
+      sectionLines("Route", {
+        ...routeSectionExtra,
+        Scope: this.scope,
+        Metric: this.metric,
+        InitialCongestionWindow: 20,
+        InitialAdvertisedReceiveWindow: 20
+      }),
+      "",
+      sectionLines("IPv6AcceptRA", {
+        UseAutonomousPrefix: "true",
+        UseOnLinkPrefix: "true",
+        DHCPv6Client: "false",
+        Token: "eui64"
+      })
+    );
+
+    if (this.arpbridge) {
+      networkSections.push("", sectionLines("Link", { Promiscuous: "yes" }));
+    }
+
+    await writeLines(networkDir, `${this.name}.network`, networkSections);
+  }
+}

package/src/network-interfaces/skeleton.mjs

@@ -0,0 +1,114 @@
+import { join } from "node:path";
+import { NetworkAddress, Base } from "pmcf";
+import { writeLines, sectionLines } from "../utils.mjs";
+import { cidrAddresses } from "../network-support.mjs";
+
+export class SkeletonNetworkInterface extends Base {
+  _extends = [];
+  _network;
+
+  static get typeName() {
+    return "network_interface";
+  }
+
+  get typeName() {
+    return "network_interface";
+  }
+
+  set extends(value) {
+    this._extends.push(value);
+  }
+
+  get extends() {
+    return this._extends;
+  }
+
+  get isTemplate() {
+    return this.name.indexOf("*") >= 0;
+  }
+
+  get host() {
+    return this.owner;
+  }
+
+  get network_interface() {
+    return this;
+  }
+
+  get domainNames() {
+    return new Set();
+  }
+
+  matches(other) {
+    if (this.isTemplate) {
+      const name = this.name.replaceAll("*", "");
+      return name.length === 0 || other.name.indexOf(name) >= 0;
+    }
+
+    return false;
+  }
+
+  get network() {
+    return this.extendedProperty("_network") ?? this.host.network;
+  }
+
+  set network(network) {
+    this._network = network;
+  }
+
+  get ipAddresses() {
+    return new Map();
+  }
+
+  /**
+   *
+   * @param {object} filter
+   * @return {Iterable<NetworkAddress>}
+   */
+  *networkAddresses(filter = n => true) {
+    for (const [address, subnet] of this.ipAddresses) {
+      const networkAddress = new NetworkAddress(this, address, subnet);
+
+      if (filter(networkAddress)) {
+        yield networkAddress;
+      }
+    }
+  }
+
+  networkAddress(filter) {
+    for (const a of this.networkAddresses(filter)) {
+      return a;
+    }
+  }
+
+  get address() {
+    return this.addresses[0];
+  }
+
+  get addresses() {
+    return [...this.ipAddresses].map(([address]) => address);
+  }
+
+  async systemdDefinitions(packageData) {
+    const networkDir = join(packageData.dir, "etc/systemd/network");
+
+    if (this.name !== "eth0" && this.hwaddr) {
+      await writeLines(networkDir, `${this.name}.link`, [
+        sectionLines("Match", { MACAddress: this.hwaddr }),
+        "",
+        sectionLines("Link", { Name: this.name })
+      ]);
+    }
+
+    const networkSections = [sectionLines("Match", { Name: this.name })];
+
+    for (const Address of cidrAddresses(this.networkAddresses())) {
+      networkSections.push(
+        "",
+        sectionLines("Address", {
+          Address
+        })
+      );
+    }
+  }
+}

package/src/network-interfaces/wireguard.mjs

@@ -0,0 +1,30 @@
+import { SkeletonNetworkInterface } from "./skeleton.mjs";
+import { NetworkInterfaceTypeDefinition } from "./network-interface.mjs";
+import { addType } from "../types.mjs";
+
+const WireguardNetworkInterfaceTypeDefinition = {
+  name: "wireguard",
+  specializationOf: NetworkInterfaceTypeDefinition,
+  owners: NetworkInterfaceTypeDefinition.owners,
+  extends: NetworkInterfaceTypeDefinition,
+  priority: 0.1,
+  properties: {}
+};
+
+export class WireguardNetworkInterface extends SkeletonNetworkInterface {
+  static {
+    addType(this);
+  }
+
+  static get typeDefinition() {
+    return WireguardNetworkInterfaceTypeDefinition;
+  }
+
+  get kind() {
+    return WireguardNetworkInterfaceTypeDefinition.name;
+  }
+
+  get ipAddresses() {
+    return new Map();
+  }
+}