pmcf 2.15.0 → 2.16.0

package/src/services/dns.mjs

@@ -1,13 +1,9 @@
 import { join } from "node:path";
 import { createHmac } from "node:crypto";
 import { FileContentProvider } from "npm-pkgbuild";
-import {
-  writeLines,
-  isIPv6Address,
-  isLinkLocal,
-  isLocalhost
-} from "../utils.mjs";
-import { DNSRecord, dnsFullName, reverseArpaAddress } from "../dns-utils.mjs";
+import { writeLines } from "../utils.mjs";
+import { isIPv6, isLinkLocal, isLocalhost, reverseArpa } from "../ip.mjs";
+import { DNSRecord, dnsFullName } from "../dns-utils.mjs";
 import { addType } from "../types.mjs";
 import { ServiceTypeDefinition, serviceAddresses } from "../service.mjs";
 import {
@@ -211,9 +207,10 @@ export class DNSService extends ExtraSourceService {
       yield packageData;
     }
 
-    const p2 = (packageData.dir = join(dir, "p2"));
+    const p2 = join(dir, "p2");
 
     packageData.properties = {
+      dir: p2,
       name: `named-zones-${name}`,
       description: `zone definitions for ${location.fullName}`,
       dependencies: ["mf-named"],
@@ -292,7 +289,7 @@ async function generateZoneDefs(dns, location, packageData) {
       for (const address of host.rawAddresses) {
         if (!isLocalhost(address)) {
           zone.records.add(
-            DNSRecord("@", isIPv6Address(address) ? "AAAA" : "A", address)
+            DNSRecord("@", isIPv6(address) ? "AAAA" : "A", address)
           );
         }
       }
@@ -366,7 +363,7 @@ async function generateZoneDefs(dns, location, packageData) {
             zone.records.add(
               DNSRecord(
                 dnsFullName(domainName),
-                isIPv6Address(address) ? "AAAA" : "A",
+                isIPv6(address) ? "AAAA" : "A",
                 address
               )
             );
@@ -375,11 +372,11 @@ async function generateZoneDefs(dns, location, packageData) {
             let reverseZone = reverseZones.get(subnet.address);
 
             if (!reverseZone) {
-              const reverseArpa = reverseArpaAddress(subnet.prefix);
+              const id = reverseArpa(subnet.prefix);
               reverseZone = {
-                id: reverseArpa,
+                id,
                 type: "plain",
-                file: `${locationName}/${reverseArpa}.zone`,
+                file: `${locationName}/${id}.zone`,
                 records: new Set([SOARecord, NSRecord])
               };
               config.zones.push(reverseZone);
@@ -389,7 +386,7 @@ async function generateZoneDefs(dns, location, packageData) {
             for (const domainName of host.domainNames) {
               reverseZone.records.add(
                 DNSRecord(
-                  dnsFullName(reverseArpaAddress(address)),
+                  dnsFullName(reverseArpa(address)),
                   "PTR",
                   dnsFullName(domainName)
                 )

package/src/subnet.mjs

@@ -1,10 +1,4 @@
-import {
-  normalizeCIDR,
-  isLinkLocal,
-  isIPv4Address,
-  isIPv6Address,
-  addressWithPrefixLength
-} from "./utils.mjs";
+import { normalizeCIDR, isLinkLocal, isIPv4, isIPv6, prefixIP } from "./ip.mjs";
 import { Base } from "./base.mjs";
 import { addType } from "./types.mjs";
 
@@ -37,9 +31,13 @@ export class Subnet extends Base {
   }
 
   constructor(owner, address) {
-    const { cidr } = normalizeCIDR(address);
+    const { longPrefix, prefix, prefixLength, cidr } = normalizeCIDR(address);
     super(owner, cidr);
     owner.addObject(this);
+
+    this.prefix = prefix;
+    this.prefixLength = prefixLength;
+    this.longPrefix = longPrefix;
   }
 
   get fullName() {
@@ -55,36 +53,20 @@ export class Subnet extends Base {
   }
 
   get isIPv4() {
-    return isIPv4Address(this.address);
+    return isIPv4(this.address);
   }
 
   get isIPv6() {
-    return isIPv6Address(this.address);
+    return isIPv6(this.address);
   }
 
   get addressRange() {
     return [
-      addressWithPrefixLength(this.prefix, this.prefixLength),
+      prefixIP(this.prefix, this.prefixLength),
       this.prefix + ".255".repeat((32 - this.prefixLength) / 8)
     ];
   }
 
-  get longPrefix() {
-    return addressWithPrefixLength(this.prefix, this.prefixLength);
-  }
-
-  get prefix() {
-    const [prefix] = this.name.split("/");
-    return prefix;
-  }
-
-  get prefixLength() {
-    const m = this.name.match(/\/(\d+)$/);
-    if (m) {
-      return parseInt(m[1]);
-    }
-  }
-
   get address() {
     return this.name;
   }

package/src/utils.mjs

@@ -77,205 +77,3 @@ export function asIterator(value) {
 
   return asArray(value);
 }
-
-export function isIPv4Address(address) {
-  switch (typeof address) {
-    case "string":
-      return address.indexOf(".") >= 0;
-  }
-
-  return false;
-}
-
-export function isIPv6Address(address) {
-  switch (typeof address) {
-    case "string":
-      return address.indexOf(":") >= 0;
-  }
-
-  return false;
-}
-
-export function isLinkLocal(address) {
-  switch (typeof address) {
-    case "string":
-      return address.startsWith("fe80");
-
-    case "bigint":
-      return ((address >> 112n) & 0xffffn) === 0xfe80n;
-  }
-
-  return false;
-}
-
-export function generateEU64(mac) {
-  //TODO
-}
-
-export function isLocalhost(address) {
-  const eaddr = encodeIP(address);
-  return eaddr === IPV4_LOCALHOST || eaddr === IPV6_LOCALHOST;
-}
-
-export function normalizeIPAddress(address) {
-  address = address.replace(/\/\d+$/, "");
-  if (isIPv4Address(address)) {
-    return address;
-  }
-  const parts = address.split(":");
-  const i = parts.indexOf("");
-  if (i >= 0) {
-    parts.splice(i, 1, ..."0".repeat(9 - parts.length));
-  }
-  return parts.map(s => s.padStart(4, "0")).join(":");
-}
-
-const ipv4 = {
-  separator: ".",
-  length: 32,
-  segmentLength: 8,
-  segmentMask: 0xffn,
-  mask: 0xffffffffn,
-  base: 10
-};
-const ipv6 = {
-  separator: ":",
-  compressor: "::",
-  length: 128,
-  segmentLength: 16,
-  segmentMask: 0xffffn,
-  mask: 0xffffffffffffffffffffffffffffffffn,
-  base: 16
-};
-
-export function addressWithPrefixLength(address, prefixLength) {
-  const definition = ipv4;
-
-  return (
-    address +
-    ".0".repeat((definition.length - prefixLength) / definition.segmentLength)
-  );
-}
-
-function _decode(definition, address, length = definition.length) {
-  if (typeof address === "string") {
-    return address;
-  }
-
-  let result = "";
-  let compressed = 0;
-  let shift = definition.length;
-  let word;
-  const last = length / definition.segmentLength;
-
-  for (let i = 0, j = 0; i < last; j = j + 1, i = j) {
-    for (; j < last; j++) {
-      shift -= definition.segmentLength;
-      word = (address >> BigInt(shift)) & definition.segmentMask;
-
-      if (word !== 0n || !definition.compressor || compressed > 0) {
-        break;
-      }
-    }
-
-    if (j > i + 1) {
-      compressed++;
-      result += definition.compressor;
-    } else {
-      if (result.length > 0) {
-        result += definition.separator;
-      }
-    }
-
-    if (j < last) {
-      result += word.toString(definition.base);
-    }
-  }
-
-  return result;
-}
-
-export function _encode(definition, address) {
-  if (typeof address !== "string") {
-    return address;
-  }
-
-  let res = 0n;
-  let shift = BigInt(definition.length);
-
-  for (const word of normalizeIPAddress(address)
-    .split(definition.separator)
-    .map(a => parseInt(a, definition.base))) {
-    shift -= BigInt(definition.segmentLength);
-    res += BigInt(word) << shift;
-  }
-
-  return res;
-}
-
-export function decodeIPv6(address, length) {
-  return _decode(ipv6, address, length);
-}
-
-export function encodeIPv6(address) {
-  return _encode(ipv6, address);
-}
-
-export function decodeIPv4(address, length) {
-  return _decode(ipv4, address, length);
-}
-
-export function encodeIPv4(address) {
-  return _encode(ipv4, address);
-}
-
-export function decodeIP(address, length) {
-  return _decode(isIPv4Address(address) ? ipv4 : ipv6, address, length);
-}
-
-export function encodeIP(address) {
-  return _encode(isIPv4Address(address) ? ipv4 : ipv6, address);
-}
-
-export function formatCIDR(address, subnet) {
-  return subnet ? `${address}/${subnet.prefixLength}` : address;
-}
-
-export function normalizeCIDR(address) {
-  let [prefix, prefixLength] = address.split(/\//);
-
-  if (!prefixLength && isLinkLocal(address)) {
-    prefix = "fe80::";
-    prefixLength = 64;
-  } else {
-    const definition = isIPv6Address(prefix) ? ipv6 : ipv4;
-    let n = _encode(definition, prefix);
-
-    if (prefixLength) {
-      n = n & (definition.mask << BigInt(definition.length - prefixLength));
-      prefix = _decode(definition, n, prefixLength);
-    } else {
-      if (n === IPV4_LOCALHOST) {
-        prefixLength = 8;
-        prefix = _decode(definition, n, prefixLength);
-      } else if (n === IPV6_LOCALHOST) {
-        prefixLength = 128;
-        prefix = _decode(definition, n, prefixLength);
-      } else {
-        return {};
-      }
-    }
-  }
-
-  return { prefix, prefixLength, cidr: `${prefix}/${prefixLength}` };
-}
-
-export function hasWellKnownSubnet(address) {
-  const n = encodeIP(address);
-  return n === IPV4_LOCALHOST || n === IPV6_LOCALHOST || isLinkLocal(address);
-}
-
-export const IPV4_LOCALHOST = _encode(ipv4, "127.0.0.1");
-export const IPV6_LOCALHOST = _encode(ipv6, "::1");
-export const IPV6_LINK_LOCAL_BROADCAST = _encode(ipv6, "ff02::1");
-export const IPV6_ROUTER_BROADCAST = _encode(ipv6, "ff02::2");

package/types/dns-utils.d.mts

@@ -7,5 +7,3 @@ export function dnsFormatParameters(parameters: any): string;
 export function dnsMergeParameters(a: any, b: any): {
     [k: string]: Set<any>;
 };
-export function reverseAddress(address: any): any;
-export function reverseArpaAddress(address: any): string;

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

@@ -74,43 +74,43 @@ export class ExtraSourceService extends Service {
                     collection: boolean;
                     writeable: boolean;
                 };
-                port: {
+                alias: {
                     type: string;
                     collection: boolean;
                     writeable: boolean;
                 };
-                protocol: {
+                weight: {
                     type: string;
                     collection: boolean;
                     writeable: boolean;
-                    values: string[];
+                    default: number;
                 };
-                alias: {
+                systemd: {
                     type: string;
                     collection: boolean;
                     writeable: boolean;
                 };
-                type: {
+                port: {
                     type: string;
                     collection: boolean;
                     writeable: boolean;
                 };
-                weight: {
+                protocol: {
                     type: string;
                     collection: boolean;
                     writeable: boolean;
-                    default: number;
+                    values: string[];
                 };
-                tls: {
+                type: {
                     type: string;
                     collection: boolean;
                     writeable: boolean;
-                    default: boolean;
                 };
-                systemd: {
+                tls: {
                     type: string;
                     collection: boolean;
                     writeable: boolean;
+                    default: boolean;
                 };
                 hostName: {
                     type: string;

package/types/ip.d.mts

@@ -0,0 +1,36 @@
+export function IPV4(...args: any[]): any;
+export function IPV6(...args: any[]): any;
+export function encodeIP(address: any): any;
+export function encodeIPv6(address: any): any;
+export function encodeIPv4(address: any): any;
+export function _encode(definition: any, address: any): any;
+export function decodeIPv6(address: any, length: any): string;
+export function decodeIPv4(address: any, length: any): string;
+export function decodeIP(address: any, length: any): string;
+export function isIPv4(address: any): boolean;
+export function isIPv6(address: any): boolean;
+export function _is(definition: any, address: any): boolean;
+export function asBigInt(address: any): bigint;
+export function prefixIP(address: any, length: any): string;
+export function _prefix(definition: any, address: any, length: any): bigint;
+export function normalizeCIDR(address: any): {
+    longPrefix?: undefined;
+    prefix?: undefined;
+    prefixLength?: undefined;
+    cidr?: undefined;
+} | {
+    longPrefix: any;
+    prefix: any;
+    prefixLength: any;
+    cidr: string;
+};
+export function formatCIDR(address: any, subnet: any): any;
+export function normalizeIP(address: any): string;
+export function reverseArpa(address: any): string;
+export function isLocalhost(address: any): boolean;
+export function isLinkLocal(address: any): boolean;
+export function hasWellKnownSubnet(address: any): boolean;
+export const IPV6_LINK_LOCAL_BROADCAST: any;
+export const IPV6_ROUTER_BROADCAST: any;
+export const IPV4_LOCALHOST: any;
+export const IPV6_LOCALHOST: any;

package/types/service.d.mts

@@ -1,9 +1,54 @@
 export function serviceAddresses(sources: any, filter: any, addressType?: string, addressFilter?: (a: any) => boolean): any[];
 export function serviceEndpoints(sources: any, filter: any): any[];
-export namespace ServiceTypeDefinition {
+export namespace endpointProperties {
+    export namespace port {
+        let type: string;
+        let collection: boolean;
+        let writeable: boolean;
+    }
+    export namespace protocol {
+        let type_1: string;
+        export { type_1 as type };
+        let collection_1: boolean;
+        export { collection_1 as collection };
+        let writeable_1: boolean;
+        export { writeable_1 as writeable };
+        export let values: string[];
+    }
+    export namespace type_2 {
+        let type_3: string;
+        export { type_3 as type };
+        let collection_2: boolean;
+        export { collection_2 as collection };
+        let writeable_2: boolean;
+        export { writeable_2 as writeable };
+    }
+    export { type_2 as type };
+    export namespace tls {
+        let type_4: string;
+        export { type_4 as type };
+        let collection_3: boolean;
+        export { collection_3 as collection };
+        let writeable_3: boolean;
+        export { writeable_3 as writeable };
+        let _default: boolean;
+        export { _default as default };
+    }
+}
+export namespace EndpointTypeDefinition {
     export let name: string;
     export let owners: string[];
     export let priority: number;
+    export let specializations: {};
+    export { endpointProperties as properties };
+}
+export namespace ServiceTypeDefinition {
+    let name_1: string;
+    export { name_1 as name };
+    let owners_1: string[];
+    export { owners_1 as owners };
+    let priority_1: number;
+    export { priority_1 as priority };
     let _extends: {
         name: string;
         owners: any[];
@@ -52,7 +97,8 @@ export namespace ServiceTypeDefinition {
         };
     };
     export { _extends as extends };
-    export let specializations: {};
+    let specializations_1: {};
+    export { specializations_1 as specializations };
     export function factoryFor(value: any): any;
     export let properties: {
         ipAddresses: {
@@ -60,43 +106,43 @@ export namespace ServiceTypeDefinition {
             collection: boolean;
             writeable: boolean;
         };
-        port: {
+        alias: {
             type: string;
             collection: boolean;
             writeable: boolean;
         };
-        protocol: {
+        weight: {
             type: string;
             collection: boolean;
             writeable: boolean;
-            values: string[];
+            default: number;
         };
-        alias: {
+        systemd: {
             type: string;
             collection: boolean;
             writeable: boolean;
         };
-        type: {
+        port: {
             type: string;
             collection: boolean;
             writeable: boolean;
         };
-        weight: {
+        protocol: {
             type: string;
             collection: boolean;
             writeable: boolean;
-            default: number;
+            values: string[];
         };
-        tls: {
+        type: {
             type: string;
             collection: boolean;
             writeable: boolean;
-            default: boolean;
         };
-        systemd: {
+        tls: {
             type: string;
             collection: boolean;
             writeable: boolean;
+            default: boolean;
         };
         hostName: {
             type: string;
@@ -185,43 +231,43 @@ export class Service extends Base {
                 collection: boolean;
                 writeable: boolean;
             };
-            port: {
+            alias: {
                 type: string;
                 collection: boolean;
                 writeable: boolean;
             };
-            protocol: {
+            weight: {
                 type: string;
                 collection: boolean;
                 writeable: boolean;
-                values: string[];
+                default: number;
             };
-            alias: {
+            systemd: {
                 type: string;
                 collection: boolean;
                 writeable: boolean;
             };
-            type: {
+            port: {
                 type: string;
                 collection: boolean;
                 writeable: boolean;
             };
-            weight: {
+            protocol: {
                 type: string;
                 collection: boolean;
                 writeable: boolean;
-                default: number;
+                values: string[];
             };
-            tls: {
+            type: {
                 type: string;
                 collection: boolean;
                 writeable: boolean;
-                default: boolean;
             };
-            systemd: {
+            tls: {
                 type: string;
                 collection: boolean;
                 writeable: boolean;
+                default: boolean;
             };
             hostName: {
                 type: string;
@@ -268,6 +314,7 @@ export class Service extends Base {
     get addresses(): any;
     get networks(): any;
     get endpoints(): any[];
+    findEndpoints(filter: any): Generator<any, void, any>;
     set alias(value: any);
     get alias(): any;
     set port(value: any);