pmcf 2.29.2 → 2.31.0

package/src/network-interfaces/skeleton.mjs

@@ -0,0 +1,119 @@
+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;
+  }
+
+  *subnets ()
+  {
+    yield *this.ipAddresses.values();
+  }
+
+  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();
+  }
+}

package/src/network-interfaces/wlan.mjs

@@ -0,0 +1,77 @@
+import { writeFile, mkdir } from "node:fs/promises";
+import { join } from "node:path";
+import { addType } from "../types.mjs";
+import { addHook } from "../hooks.mjs";
+import { NetworkInterfaceTypeDefinition } from "./network-interface.mjs";
+import {
+  EthernetNetworkInterface,
+  EthernetNetworkInterfaceTypeDefinition
+} from "./ethernet.mjs";
+
+const WLANNetworkInterfaceTypeDefinition = {
+  name: "wlan",
+  specializationOf: NetworkInterfaceTypeDefinition,
+  owners: EthernetNetworkInterfaceTypeDefinition.owners,
+  extends: EthernetNetworkInterfaceTypeDefinition,
+  priority: 0.1,
+  properties: {}
+};
+
+export class WLANNetworkInterface extends EthernetNetworkInterface {
+  _ssid;
+  _psk;
+
+  static {
+    addType(this);
+  }
+
+  static get typeDefinition() {
+    return WLANNetworkInterfaceTypeDefinition;
+  }
+
+  get kind() {
+    return WLANNetworkInterfaceTypeDefinition.name;
+  }
+
+  set ssid(value) {
+    this._ssid = value;
+  }
+
+  get ssid() {
+    return this.extendedProperty("_ssid") ?? this.network?.ssid;
+  }
+
+  set psk(value) {
+    this._psk = value;
+  }
+
+  get psk() {
+    return this.extendedProperty("_psk") ?? this.network?.psk;
+  }
+
+  async systemdDefinitions(packageData) {
+    await super.systemdDefinitions(packageData);
+
+    const d = join(packageData.dir, "etc/wpa_supplicant");
+    await mkdir(d, { recursive: true });
+    writeFile(
+      join(d, `wpa_supplicant-${this.name}.conf`),
+      `country=${this.location.country}
+ctrl_interface=DIR=/run/wpa_supplicant GROUP=netdev
+update_config=1
+p2p_disabled=1
+network={
+  ssid="${this.ssid}"
+  psk=${this.psk}
+  scan_ssid=1
+}`,
+      "utf8"
+    );
+
+    addHook(
+      packageData.properties.hooks,
+      "post_install",
+      `systemctl enable wpa_supplicant@${this.name}.service`
+    );
+  }
+}

package/src/service.mjs

@@ -93,7 +93,7 @@ export const ServiceTypeDefinition = {
   priority: 0.4,
   extends: Base.typeDefinition,
   specializations: {},
-  factoryFor(value) {
+  factoryFor(owner,value) {
     const type = value.type ?? value.name;
     const t = ServiceTypeDefinition.specializations[type];
 

package/src/services/dns.mjs

@@ -207,7 +207,7 @@ export class DNSService extends ExtraSourceService {
           ...DNS_SERVICE_FILTER,
           priority: ">=10"
         }).join(" "),
-        Domains: [...this.domains].join(" "),
+        Domains: [...this.localDomains].join(" "),
         DNSSEC: "no",
         MulticastDNS: this.network.multicastDNS ? "yes" : "no",
         LLMNR: "no"

package/src/subnet.mjs

@@ -91,14 +91,15 @@ export class Subnet extends Base {
 }
 
 const _owner = { addObject() {} };
+export const SUBNET_GLOBAL_IPV4 = new Subnet(_owner, "0.0.0.0/0");
 export const SUBNET_LOCALHOST_IPV4 = new Subnet(_owner, "127.0.0.1/8");
 export const SUBNET_LOCALHOST_IPV6 = new Subnet(_owner, "::1/128");
 
 export function subnets(sources) {
   const all = new Set();
 
-  for (const owner of sources) {
-    for (const subnet of owner.subnets()) {
+  for (const source of sources) {
+    for (const subnet of source.subnets()) {
       all.add(subnet);
     }
   }

package/types/cluster.d.mts

@@ -242,6 +242,7 @@ export class Cluster extends Host {
                     type: string;
                     collection: boolean;
                     writeable: boolean;
+                    values: string[];
                 };
                 architecture: {
                     type: string;

package/types/extra-source-service.d.mts

@@ -67,7 +67,7 @@ export class ExtraSourceService extends Service {
                 };
             };
             specializations: {};
-            factoryFor(value: any): any;
+            factoryFor(owner: any, value: any): any;
             properties: {
                 ipAddresses: {
                     type: string;

package/types/host-utils.d.mts

@@ -1,3 +1,2 @@
 export function generateMachineInfo(host: any, packageData: any): Promise<void>;
-export function generateNetworkDefs(host: any, packageData: any): Promise<void>;
 export function generateKnownHosts(hosts: any, dir: any): Promise<void>;

package/types/host.d.mts

@@ -107,6 +107,7 @@ export class Host extends Base {
                 type: string;
                 collection: boolean;
                 writeable: boolean;
+                values: string[];
             };
             architecture: {
                 type: string;
@@ -236,6 +237,7 @@ export class Host extends Base {
     networkAddresses(filter: any): Generator<any, void, any>;
     get address(): any;
     get addresses(): any[];
+    subnets(): Generator<any, void, any>;
     publicKey(type?: string): Promise<string>;
     preparePackages(dir: any): AsyncGenerator<{
         dir: any;

package/types/module.d.mts

@@ -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/types/network-address.d.mts

@@ -1,9 +1,5 @@
 /**
- * @property {NetworkInterface} networkInterface
- * @property {string|Uint8Array|Uint16Array} address
- * @property {string} family
- * @property {Subnet} subnet
- * @property {Set<string>} domainNames
+ *
  */
 export class NetworkAddress {
     constructor(networkInterface: any, address: any, subnet: any);

package/types/network-interfaces/ethernet.d.mts

@@ -0,0 +1,338 @@
+export namespace EthernetNetworkInterfaceTypeDefinition {
+    export let name: string;
+    export { NetworkInterfaceTypeDefinition as specializationOf };
+    export let owners: string[];
+    export { NetworkInterfaceTypeDefinition as extends };
+    export let priority: number;
+    export namespace properties {
+        namespace arpbridge {
+            let type: string;
+            let collection: boolean;
+            let writeable: boolean;
+        }
+    }
+}
+export class EthernetNetworkInterface extends NetworkInterface {
+    static get typeDefinition(): {
+        name: string;
+        specializationOf: {
+            name: string;
+            priority: number;
+            owners: string[];
+            extends: {
+                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;
+                    };
+                    priority: {
+                        type: string;
+                        collection: boolean;
+                        writeable: boolean;
+                    };
+                    directory: {
+                        type: string;
+                        collection: boolean;
+                        writeable: boolean;
+                    };
+                    packaging: {
+                        type: string;
+                        collection: boolean;
+                        writeable: boolean;
+                    };
+                    tags: {
+                        type: string;
+                        collection: boolean;
+                        writeable: boolean;
+                    };
+                };
+            };
+            specializations: {};
+            factoryFor(owner: any, value: any): any;
+            properties: {
+                hostName: {
+                    type: string;
+                    collection: boolean;
+                    writeable: boolean;
+                };
+                ipAddresses: {
+                    type: string;
+                    collection: boolean;
+                    writeable: boolean;
+                };
+                hwaddr: {
+                    type: string;
+                    collection: boolean;
+                    writeable: boolean;
+                };
+                network: {
+                    type: string;
+                    collection: boolean;
+                    writeable: boolean;
+                };
+                destination: {
+                    type: string;
+                    collection: boolean;
+                    writeable: boolean;
+                };
+                cidrAddresses: {
+                    type: string;
+                    collection: boolean;
+                    writeable: boolean;
+                };
+                cidrAddress: {
+                    type: string;
+                    collection: boolean;
+                    writeable: boolean;
+                };
+                addresses: {
+                    type: string;
+                    collection: boolean;
+                    writeable: boolean;
+                };
+                address: {
+                    type: string;
+                    collection: boolean;
+                    writeable: boolean;
+                };
+                scope: {
+                    type: string;
+                    collection: boolean;
+                    writeable: boolean;
+                    values: string[];
+                    default: string;
+                };
+                class: {
+                    type: string;
+                    collection: boolean;
+                    writeable: boolean;
+                    values: string[];
+                };
+                kind: {
+                    type: string;
+                    collection: boolean;
+                    writeable: boolean;
+                    values: string[];
+                };
+                ssid: {
+                    type: string;
+                    collection: boolean;
+                    writeable: boolean;
+                };
+                psk: {
+                    type: string;
+                    collection: boolean;
+                    writeable: boolean;
+                };
+                metric: {
+                    type: string;
+                    collection: boolean;
+                    writeable: boolean;
+                    default: number;
+                };
+                MTU: {
+                    type: string;
+                    collection: boolean;
+                    writeable: boolean;
+                    default: number;
+                };
+                gateway: {
+                    type: string;
+                    collection: boolean;
+                    writeable: boolean;
+                };
+                multicastDNS: {
+                    type: string;
+                    collection: boolean;
+                    writeable: boolean;
+                    default: boolean;
+                };
+            };
+        };
+        owners: string[];
+        extends: {
+            name: string;
+            priority: number;
+            owners: string[];
+            extends: {
+                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;
+                    };
+                    priority: {
+                        type: string;
+                        collection: boolean;
+                        writeable: boolean;
+                    };
+                    directory: {
+                        type: string;
+                        collection: boolean;
+                        writeable: boolean;
+                    };
+                    packaging: {
+                        type: string;
+                        collection: boolean;
+                        writeable: boolean;
+                    };
+                    tags: {
+                        type: string;
+                        collection: boolean;
+                        writeable: boolean;
+                    };
+                };
+            };
+            specializations: {};
+            factoryFor(owner: any, value: any): any;
+            properties: {
+                hostName: {
+                    type: string;
+                    collection: boolean;
+                    writeable: boolean;
+                };
+                ipAddresses: {
+                    type: string;
+                    collection: boolean;
+                    writeable: boolean;
+                };
+                hwaddr: {
+                    type: string;
+                    collection: boolean;
+                    writeable: boolean;
+                };
+                network: {
+                    type: string;
+                    collection: boolean;
+                    writeable: boolean;
+                };
+                destination: {
+                    type: string;
+                    collection: boolean;
+                    writeable: boolean;
+                };
+                cidrAddresses: {
+                    type: string;
+                    collection: boolean;
+                    writeable: boolean;
+                };
+                cidrAddress: {
+                    type: string;
+                    collection: boolean;
+                    writeable: boolean;
+                };
+                addresses: {
+                    type: string;
+                    collection: boolean;
+                    writeable: boolean;
+                };
+                address: {
+                    type: string;
+                    collection: boolean;
+                    writeable: boolean;
+                };
+                scope: {
+                    type: string;
+                    collection: boolean;
+                    writeable: boolean;
+                    values: string[];
+                    default: string;
+                };
+                class: {
+                    type: string;
+                    collection: boolean;
+                    writeable: boolean;
+                    values: string[];
+                };
+                kind: {
+                    type: string;
+                    collection: boolean;
+                    writeable: boolean;
+                    values: string[];
+                };
+                ssid: {
+                    type: string;
+                    collection: boolean;
+                    writeable: boolean;
+                };
+                psk: {
+                    type: string;
+                    collection: boolean;
+                    writeable: boolean;
+                };
+                metric: {
+                    type: string;
+                    collection: boolean;
+                    writeable: boolean;
+                    default: number;
+                };
+                MTU: {
+                    type: string;
+                    collection: boolean;
+                    writeable: boolean;
+                    default: number;
+                };
+                gateway: {
+                    type: string;
+                    collection: boolean;
+                    writeable: boolean;
+                };
+                multicastDNS: {
+                    type: string;
+                    collection: boolean;
+                    writeable: boolean;
+                    default: boolean;
+                };
+            };
+        };
+        priority: number;
+        properties: {
+            arpbridge: {
+                type: string;
+                collection: boolean;
+                writeable: boolean;
+            };
+        };
+    };
+    arpbridge: any;
+    get kind(): string;
+}
+import { NetworkInterfaceTypeDefinition } from "./network-interface.mjs";
+import { NetworkInterface } from "./network-interface.mjs";