mirror of
https://github.com/oddlama/nixos-extra-modules.git
synced 2025-10-10 22:00:39 +02:00
feat: implement pure nix shift
This commit is contained in:
Patrick
parent
8daa7e8318
commit
ddc2349760
3 changed files with 344 additions and 254 deletions
408
lib/net.nix
408
lib/net.nix
|
|
@ -1,6 +1,6 @@
|
|||
inputs: _final: prev: let
|
||||
inherit
|
||||
(prev.lib)
|
||||
inputs: _final: prev:
|
||||
let
|
||||
inherit (prev.lib)
|
||||
all
|
||||
any
|
||||
assertMsg
|
||||
|
|
@ -22,24 +22,29 @@ inputs: _final: prev: let
|
|||
;
|
||||
|
||||
# From misc.nix
|
||||
inherit
|
||||
(prev.lib)
|
||||
inherit (prev.lib)
|
||||
hexToDec
|
||||
pow
|
||||
;
|
||||
|
||||
# IP address math library
|
||||
# https://gist.github.com/duairc/5c9bb3c922e5d501a1edb9e7b3b845ba
|
||||
# Plus some extensions by us
|
||||
libNet =
|
||||
(import "${inputs.lib-net}/net.nix" {
|
||||
(import ./netu.nix {
|
||||
inherit (inputs.nixpkgs) lib;
|
||||
})
|
||||
.lib
|
||||
.net;
|
||||
in {
|
||||
}).lib.net;
|
||||
in
|
||||
{
|
||||
lib = recursiveUpdate prev.lib {
|
||||
net = recursiveUpdate (removeAttrs libNet ["types"]) {
|
||||
inherit (libNet)
|
||||
arithmetic
|
||||
typechecks
|
||||
bit
|
||||
implementations
|
||||
parsers
|
||||
;
|
||||
|
||||
net = recursiveUpdate (removeAttrs libNet [ "types" ]) {
|
||||
cidr = rec {
|
||||
# host :: (ip | mac | integer) -> cidr -> ip
|
||||
#
|
||||
|
|
@ -58,11 +63,13 @@ in {
|
|||
# "192.168.1.0"
|
||||
# > net.cidr.host (-257) "192.168.1.0/24"
|
||||
# <fails with an error message>
|
||||
host = i: n: let
|
||||
cap = libNet.cidr.capacity n;
|
||||
in
|
||||
host =
|
||||
i: n:
|
||||
let
|
||||
cap = libNet.cidr.capacity n;
|
||||
in
|
||||
assert assertMsg (i >= (-cap) && i < cap) "The host ${toString i} lies outside of ${n}";
|
||||
libNet.cidr.host i n;
|
||||
libNet.cidr.host i n;
|
||||
# hostCidr :: (ip | mac | integer) -> cidr -> cidr
|
||||
#
|
||||
# Returns the nth host in the given cidr range (like cidr.host)
|
||||
|
|
@ -103,37 +110,30 @@ in {
|
|||
#
|
||||
# > net.cidr.mergev4 ["192.168.1.1/24" "192.168.6.1/32"]
|
||||
# "192.168.0.0/21"
|
||||
mergev4 = addrs_: let
|
||||
# Append /32 if necessary
|
||||
addrs = map (x:
|
||||
if hasInfix "/" x
|
||||
then x
|
||||
else "${x}/32")
|
||||
addrs_;
|
||||
# The smallest occurring length is the first we need to start checking, since
|
||||
# any greater cidr length represents a smaller address range which
|
||||
# wouldn't contain all of the original addresses.
|
||||
startLength = foldl' min 32 (map libNet.cidr.length addrs);
|
||||
possibleLengths = reverseList (range 0 startLength);
|
||||
# The first ip address will be "expanded" in cidr length until it covers all other
|
||||
# used addresses.
|
||||
firstIp = ip (head addrs);
|
||||
# Return the first (i.e. greatest length -> smallest prefix) cidr length
|
||||
# in the list that covers all used addresses
|
||||
bestLength = head (filter
|
||||
# All given addresses must be contained by the generated address.
|
||||
(len:
|
||||
all (x:
|
||||
libNet.cidr.contains
|
||||
(ip x)
|
||||
(libNet.cidr.make len firstIp))
|
||||
addrs)
|
||||
possibleLengths);
|
||||
in
|
||||
mergev4 =
|
||||
addrs_:
|
||||
let
|
||||
# Append /32 if necessary
|
||||
addrs = map (x: if hasInfix "/" x then x else "${x}/32") addrs_;
|
||||
# The smallest occurring length is the first we need to start checking, since
|
||||
# any greater cidr length represents a smaller address range which
|
||||
# wouldn't contain all of the original addresses.
|
||||
startLength = foldl' min 32 (map libNet.cidr.length addrs);
|
||||
possibleLengths = reverseList (range 0 startLength);
|
||||
# The first ip address will be "expanded" in cidr length until it covers all other
|
||||
# used addresses.
|
||||
firstIp = ip (head addrs);
|
||||
# Return the first (i.e. greatest length -> smallest prefix) cidr length
|
||||
# in the list that covers all used addresses
|
||||
bestLength = head (
|
||||
filter
|
||||
# All given addresses must be contained by the generated address.
|
||||
(len: all (x: libNet.cidr.contains (ip x) (libNet.cidr.make len firstIp)) addrs)
|
||||
possibleLengths
|
||||
);
|
||||
in
|
||||
assert assertMsg (!any (hasInfix ":") addrs) "mergev4 cannot operate on ipv6 addresses";
|
||||
if addrs == []
|
||||
then null
|
||||
else libNet.cidr.make bestLength firstIp;
|
||||
if addrs == [ ] then null else libNet.cidr.make bestLength firstIp;
|
||||
# mergev6 :: [cidrv6 | ipv6] -> (cidrv6 | null)
|
||||
#
|
||||
# Returns the smallest cidr network that includes all given networks.
|
||||
|
|
@ -143,48 +143,44 @@ in {
|
|||
#
|
||||
# > net.cidr.mergev6 ["fd00:dead:cafe::/64" "fd00:fd12:3456:7890::/56"]
|
||||
# "fd00:c000::/18"
|
||||
mergev6 = addrs_: let
|
||||
# Append /128 if necessary
|
||||
addrs = map (x:
|
||||
if hasInfix "/" x
|
||||
then x
|
||||
else "${x}/128")
|
||||
addrs_;
|
||||
# The smallest occurring length is the first we need to start checking, since
|
||||
# any greater cidr length represents a smaller address range which
|
||||
# wouldn't contain all of the original addresses.
|
||||
startLength = foldl' min 128 (map libNet.cidr.length addrs);
|
||||
possibleLengths = reverseList (range 0 startLength);
|
||||
# The first ip address will be "expanded" in cidr length until it covers all other
|
||||
# used addresses.
|
||||
firstIp = ip (head addrs);
|
||||
# Return the first (i.e. greatest length -> smallest prefix) cidr length
|
||||
# in the list that covers all used addresses
|
||||
bestLength = head (filter
|
||||
# All given addresses must be contained by the generated address.
|
||||
(len:
|
||||
all (x:
|
||||
libNet.cidr.contains
|
||||
(ip x)
|
||||
(libNet.cidr.make len firstIp))
|
||||
addrs)
|
||||
possibleLengths);
|
||||
in
|
||||
mergev6 =
|
||||
addrs_:
|
||||
let
|
||||
# Append /128 if necessary
|
||||
addrs = map (x: if hasInfix "/" x then x else "${x}/128") addrs_;
|
||||
# The smallest occurring length is the first we need to start checking, since
|
||||
# any greater cidr length represents a smaller address range which
|
||||
# wouldn't contain all of the original addresses.
|
||||
startLength = foldl' min 128 (map libNet.cidr.length addrs);
|
||||
possibleLengths = reverseList (range 0 startLength);
|
||||
# The first ip address will be "expanded" in cidr length until it covers all other
|
||||
# used addresses.
|
||||
firstIp = ip (head addrs);
|
||||
# Return the first (i.e. greatest length -> smallest prefix) cidr length
|
||||
# in the list that covers all used addresses
|
||||
bestLength = head (
|
||||
filter
|
||||
# All given addresses must be contained by the generated address.
|
||||
(len: all (x: libNet.cidr.contains (ip x) (libNet.cidr.make len firstIp)) addrs)
|
||||
possibleLengths
|
||||
);
|
||||
in
|
||||
assert assertMsg (all (hasInfix ":") addrs) "mergev6 cannot operate on ipv4 addresses";
|
||||
if addrs == []
|
||||
then null
|
||||
else libNet.cidr.make bestLength firstIp;
|
||||
if addrs == [ ] then null else libNet.cidr.make bestLength firstIp;
|
||||
# merge :: [cidr] -> { cidrv4 = (cidrv4 | null); cidrv6 = (cidrv4 | null); }
|
||||
#
|
||||
# Returns the smallest cidr network that includes all given networks,
|
||||
# but yields two separate result for all given ipv4 and ipv6 addresses.
|
||||
# Equivalent to calling mergev4 and mergev6 on a partition individually.
|
||||
merge = addrs: let
|
||||
v4_and_v6 = partition (hasInfix ":") addrs;
|
||||
in {
|
||||
cidrv4 = mergev4 v4_and_v6.wrong;
|
||||
cidrv6 = mergev6 v4_and_v6.right;
|
||||
};
|
||||
merge =
|
||||
addrs:
|
||||
let
|
||||
v4_and_v6 = partition (hasInfix ":") addrs;
|
||||
in
|
||||
{
|
||||
cidrv4 = mergev4 v4_and_v6.wrong;
|
||||
cidrv6 = mergev6 v4_and_v6.right;
|
||||
};
|
||||
# assignIps :: cidr -> [int | ip] -> [string] -> [ip]
|
||||
#
|
||||
# Assigns a semi-stable ip address from the given cidr network to each hostname.
|
||||
|
|
@ -203,68 +199,76 @@ in {
|
|||
#
|
||||
# > net.cidr.assignIps "192.168.100.1/24" [202 "192.168.100.74"] ["a" "b" "c"]
|
||||
# { a = "192.168.100.203"; b = "192.168.100.75"; c = "192.168.100.226"; }
|
||||
assignIps = net: reserved: hosts: let
|
||||
cidrSize = libNet.cidr.size net;
|
||||
capacity = libNet.cidr.capacity net;
|
||||
# The base address of the network. Used to convert ip-based reservations to offsets
|
||||
baseAddr = host 0 net;
|
||||
# Reserve some values for the network, host and broadcast address.
|
||||
# The network and broadcast address should never be used, and we
|
||||
# want to reserve the host address for the host. We also convert
|
||||
# any ips to offsets here.
|
||||
init = unique (
|
||||
[0 (capacity - 1)]
|
||||
++ flip map reserved (x:
|
||||
if builtins.typeOf x == "int"
|
||||
then x
|
||||
else -(libNet.ip.diff baseAddr x))
|
||||
);
|
||||
nHosts = builtins.length hosts;
|
||||
nInit = builtins.length init;
|
||||
# Pre-sort all hosts, to ensure ordering invariance
|
||||
sortedHosts =
|
||||
warnIf
|
||||
((nInit + nHosts) > 0.3 * capacity)
|
||||
"assignIps: hash stability may be degraded since utilization is >30%"
|
||||
(builtins.sort builtins.lessThan hosts);
|
||||
# Generates a hash (i.e. offset value) for a given hostname
|
||||
hashElem = x:
|
||||
builtins.bitAnd (capacity - 1)
|
||||
(hexToDec (builtins.substring 0 16 (builtins.hashString "sha256" x)));
|
||||
# Do linear probing. Returns the first unused value at or after the given value.
|
||||
probe = avoid: value:
|
||||
if elem value avoid
|
||||
# TODO lib.mod
|
||||
# Poor man's modulo, because nix has no modulo. Luckily we operate on a residue
|
||||
# class of x modulo 2^n, so we can use bitAnd instead.
|
||||
then probe avoid (builtins.bitAnd (capacity - 1) (value + 1))
|
||||
else value;
|
||||
# Hash a new element and avoid assigning any existing values.
|
||||
assignOne = {
|
||||
assigned,
|
||||
used,
|
||||
}: x: let
|
||||
value = probe used (hashElem x);
|
||||
in {
|
||||
assigned =
|
||||
assigned
|
||||
// {
|
||||
${x} = host value net;
|
||||
assignIps =
|
||||
net: reserved: hosts:
|
||||
let
|
||||
cidrSize = libNet.cidr.size net;
|
||||
capacity = libNet.cidr.capacity net;
|
||||
# The base address of the network. Used to convert ip-based reservations to offsets
|
||||
baseAddr = host 0 net;
|
||||
# Reserve some values for the network, host and broadcast address.
|
||||
# The network and broadcast address should never be used, and we
|
||||
# want to reserve the host address for the host. We also convert
|
||||
# any ips to offsets here.
|
||||
init = unique (
|
||||
[
|
||||
0
|
||||
(capacity - 1)
|
||||
]
|
||||
++ flip map reserved (x: if builtins.typeOf x == "int" then x else -(libNet.ip.diff baseAddr x))
|
||||
);
|
||||
nHosts = builtins.length hosts;
|
||||
nInit = builtins.length init;
|
||||
# Pre-sort all hosts, to ensure ordering invariance
|
||||
sortedHosts =
|
||||
warnIf ((nInit + nHosts) > 0.3 * capacity)
|
||||
"assignIps: hash stability may be degraded since utilization is >30%"
|
||||
(builtins.sort builtins.lessThan hosts);
|
||||
# Generates a hash (i.e. offset value) for a given hostname
|
||||
hashElem =
|
||||
x:
|
||||
builtins.bitAnd (capacity - 1) (
|
||||
hexToDec (builtins.substring 0 16 (builtins.hashString "sha256" x))
|
||||
);
|
||||
# Do linear probing. Returns the first unused value at or after the given value.
|
||||
probe =
|
||||
avoid: value:
|
||||
if
|
||||
elem value avoid
|
||||
# TODO lib.mod
|
||||
# Poor man's modulo, because nix has no modulo. Luckily we operate on a residue
|
||||
# class of x modulo 2^n, so we can use bitAnd instead.
|
||||
then
|
||||
probe avoid (builtins.bitAnd (capacity - 1) (value + 1))
|
||||
else
|
||||
value;
|
||||
# Hash a new element and avoid assigning any existing values.
|
||||
assignOne =
|
||||
{
|
||||
assigned,
|
||||
used,
|
||||
}:
|
||||
x:
|
||||
let
|
||||
value = probe used (hashElem x);
|
||||
in
|
||||
{
|
||||
assigned = assigned // {
|
||||
${x} = host value net;
|
||||
};
|
||||
used = [ value ] ++ used;
|
||||
};
|
||||
used = [value] ++ used;
|
||||
};
|
||||
in
|
||||
assert assertMsg (cidrSize >= 2 && cidrSize <= 62)
|
||||
"assignIps: cidrSize=${toString cidrSize} is not in [2, 62].";
|
||||
in
|
||||
assert assertMsg (
|
||||
cidrSize >= 2 && cidrSize <= 62
|
||||
) "assignIps: cidrSize=${toString cidrSize} is not in [2, 62].";
|
||||
assert assertMsg (nHosts <= capacity - nInit)
|
||||
"assignIps: number of hosts (${toString nHosts}) must be <= capacity (${toString capacity}) - reserved (${toString nInit})";
|
||||
"assignIps: number of hosts (${toString nHosts}) must be <= capacity (${toString capacity}) - reserved (${toString nInit})";
|
||||
# Assign an ip in the subnet to each element, in order
|
||||
(foldl' assignOne {
|
||||
assigned = {};
|
||||
used = init;
|
||||
}
|
||||
sortedHosts)
|
||||
.assigned;
|
||||
(foldl' assignOne {
|
||||
assigned = { };
|
||||
used = init;
|
||||
} sortedHosts).assigned;
|
||||
};
|
||||
ip = rec {
|
||||
# Checks whether the given address (with or without cidr notation) is an ipv4 address.
|
||||
|
|
@ -275,11 +279,14 @@ in {
|
|||
mac = {
|
||||
# Adds offset to the given base address and ensures the result is in
|
||||
# a locally administered range by replacing the second nibble with a 2.
|
||||
addPrivate = base: offset: let
|
||||
added = libNet.mac.add base offset;
|
||||
pre = substring 0 1 added;
|
||||
suf = substring 2 (-1) added;
|
||||
in "${pre}2${suf}";
|
||||
addPrivate =
|
||||
base: offset:
|
||||
let
|
||||
added = libNet.mac.add base offset;
|
||||
pre = substring 0 1 added;
|
||||
suf = substring 2 (-1) added;
|
||||
in
|
||||
"${pre}2${suf}";
|
||||
# assignMacs :: mac (base) -> int (size) -> [int | mac] (reserved) -> [string] (hosts) -> [mac]
|
||||
#
|
||||
# Assigns a semi-stable MAC address starting in [base, base + 2^size) to each hostname.
|
||||
|
|
@ -297,63 +304,64 @@ in {
|
|||
#
|
||||
# > net.mac.assignMacs "11:22:33:00:00:00" 24 ["11:22:33:1b:bd:ca"] ["a" "b" "c"]
|
||||
# { a = "11:22:33:1b:bd:cb"; b = "11:22:33:39:59:4a"; c = "11:22:33:50:7a:e2"; }
|
||||
assignMacs = base: size: reserved: hosts: let
|
||||
capacity = pow 2 size;
|
||||
baseAsInt = libNet.mac.diff base "00:00:00:00:00:00";
|
||||
init = unique (
|
||||
flip map reserved (x:
|
||||
if builtins.typeOf x == "int"
|
||||
then x
|
||||
else libNet.mac.diff x base)
|
||||
);
|
||||
nHosts = builtins.length hosts;
|
||||
nInit = builtins.length init;
|
||||
# Pre-sort all hosts, to ensure ordering invariance
|
||||
sortedHosts =
|
||||
warnIf
|
||||
((nInit + nHosts) > 0.3 * capacity)
|
||||
"assignMacs: hash stability may be degraded since utilization is >30%"
|
||||
(builtins.sort builtins.lessThan hosts);
|
||||
# Generates a hash (i.e. offset value) for a given hostname
|
||||
hashElem = x:
|
||||
builtins.bitAnd (capacity - 1)
|
||||
(hexToDec (substring 0 16 (builtins.hashString "sha256" x)));
|
||||
# Do linear probing. Returns the first unused value at or after the given value.
|
||||
probe = avoid: value:
|
||||
if elem value avoid
|
||||
# TODO lib.mod
|
||||
# Poor man's modulo, because nix has no modulo. Luckily we operate on a residue
|
||||
# class of x modulo 2^n, so we can use bitAnd instead.
|
||||
then probe avoid (builtins.bitAnd (capacity - 1) (value + 1))
|
||||
else value;
|
||||
# Hash a new element and avoid assigning any existing values.
|
||||
assignOne = {
|
||||
assigned,
|
||||
used,
|
||||
}: x: let
|
||||
value = probe used (hashElem x);
|
||||
in {
|
||||
assigned =
|
||||
assigned
|
||||
// {
|
||||
${x} = libNet.mac.add value base;
|
||||
assignMacs =
|
||||
base: size: reserved: hosts:
|
||||
let
|
||||
capacity = libNet.bit.left 1 size;
|
||||
baseAsInt = libNet.net.mac.diff base "00:00:00:00:00:00";
|
||||
init = unique (
|
||||
flip map reserved (x: if builtins.typeOf x == "int" then x else libNet.net.mac.diff x base)
|
||||
);
|
||||
nHosts = builtins.length hosts;
|
||||
nInit = builtins.length init;
|
||||
# Pre-sort all hosts, to ensure ordering invariance
|
||||
sortedHosts =
|
||||
warnIf ((nInit + nHosts) > 0.3 * capacity)
|
||||
"assignMacs: hash stability may be degraded since utilization is >30%"
|
||||
(builtins.sort builtins.lessThan hosts);
|
||||
# Generates a hash (i.e. offset value) for a given hostname
|
||||
hashElem =
|
||||
x: builtins.bitAnd (capacity - 1) (hexToDec (substring 0 16 (builtins.hashString "sha256" x)));
|
||||
# Do linear probing. Returns the first unused value at or after the given value.
|
||||
probe =
|
||||
avoid: value:
|
||||
if
|
||||
elem value avoid
|
||||
# TODO lib.mod
|
||||
# Poor man's modulo, because nix has no modulo. Luckily we operate on a residue
|
||||
# class of x modulo 2^n, so we can use bitAnd instead.
|
||||
then
|
||||
probe avoid (builtins.bitAnd (capacity - 1) (value + 1))
|
||||
else
|
||||
value;
|
||||
# Hash a new element and avoid assigning any existing values.
|
||||
assignOne =
|
||||
{
|
||||
assigned,
|
||||
used,
|
||||
}:
|
||||
x:
|
||||
let
|
||||
value = probe used (hashElem x);
|
||||
in
|
||||
{
|
||||
assigned = assigned // {
|
||||
${x} = libNet.net.mac.add value base;
|
||||
};
|
||||
used = [ value ] ++ used;
|
||||
};
|
||||
used = [value] ++ used;
|
||||
};
|
||||
in
|
||||
assert assertMsg (size >= 2 && size <= 62)
|
||||
"assignMacs: size=${toString size} is not in [2, 62].";
|
||||
assert assertMsg (builtins.bitAnd (capacity - 1) baseAsInt == 0)
|
||||
"assignMacs: the size=${toString size} least significant bits of the base mac address must be 0.";
|
||||
in
|
||||
assert assertMsg (size >= 2 && size <= 62) "assignMacs: size=${toString size} is not in [2, 62].";
|
||||
assert assertMsg (
|
||||
builtins.bitAnd (capacity - 1) baseAsInt == 0
|
||||
) "assignMacs: the size=${toString size} least significant bits of the base mac address must be 0.";
|
||||
assert assertMsg (nHosts <= capacity - nInit)
|
||||
"assignMacs: number of hosts (${toString nHosts}) must be <= capacity (${toString capacity}) - reserved (${toString nInit})";
|
||||
"assignMacs: number of hosts (${toString nHosts}) must be <= capacity (${toString capacity}) - reserved (${toString nInit})";
|
||||
# Assign an ip in the subnet to each element, in order
|
||||
(foldl' assignOne {
|
||||
assigned = {};
|
||||
used = init;
|
||||
}
|
||||
sortedHosts)
|
||||
.assigned;
|
||||
(foldl' assignOne {
|
||||
assigned = { };
|
||||
used = init;
|
||||
} sortedHosts).assigned;
|
||||
};
|
||||
};
|
||||
types.net = libNet.types;
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue