Qyriad/dynix
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

oh right this was supposed to be http

Browse source
This commit is contained in:
Qyriad 2026-03-30 13:39:56 +02:00
parent 1ca5aa2e97
commit adaa020029
14 changed files with 1187 additions and 1040 deletions
Download patch file Download diff file Expand all files Collapse all files

772
Cargo.lock generated
View file

@ -2,6 +2,21 @@
# It is not intended for manual editing. # It is not intended for manual editing.
version = 4 version = 4
[[package]]
name = "addr2line"
version = "0.25.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "1b5d307320b3181d6d7954e663bd7c774a838b8220fe0593c86d9fb09f498b4b"
dependencies = [
"gimli",
]
[[package]]
name = "adler2"
version = "2.0.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "320119579fcad9c21884f5c4861d16174d0e06250625266f50fe6898340abefa"
[[package]] [[package]]
name = "aho-corasick" name = "aho-corasick"
version = "1.1.4" version = "1.1.4"
@ -67,12 +82,97 @@ dependencies = [
"windows-sys 0.61.2", "windows-sys 0.61.2",
] ]
[[package]]
name = "atomic-waker"
version = "1.1.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "1505bd5d3d116872e7271a6d4e16d81d0c8570876c8de68093a09ac269d8aac0"
[[package]] [[package]]
name = "autocfg" name = "autocfg"
version = "1.5.0" version = "1.5.0"
source = "registry+https://github.com/rust-lang/crates.io-index" source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "c08606f8c3cbf4ce6ec8e28fb0014a2c086708fe954eaa885384a6165172e7e8" checksum = "c08606f8c3cbf4ce6ec8e28fb0014a2c086708fe954eaa885384a6165172e7e8"
[[package]]
name = "axum"
version = "0.8.8"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "8b52af3cb4058c895d37317bb27508dccc8e5f2d39454016b297bf4a400597b8"
dependencies = [
"axum-core",
"axum-macros",
"bytes",
"form_urlencoded",
"futures-util",
"http",
"http-body",
"http-body-util",
"hyper",
"hyper-util",
"itoa",
"matchit",
"memchr",
"mime",
"percent-encoding",
"pin-project-lite",
"serde_core",
"serde_json",
"serde_path_to_error",
"serde_urlencoded",
"sync_wrapper",
"tokio",
"tower",
"tower-layer",
"tower-service",
"tracing",
]
[[package]]
name = "axum-core"
version = "0.5.6"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "08c78f31d7b1291f7ee735c1c6780ccde7785daae9a9206026862dab7d8792d1"
dependencies = [
"bytes",
"futures-core",
"http",
"http-body",
"http-body-util",
"mime",
"pin-project-lite",
"sync_wrapper",
"tower-layer",
"tower-service",
"tracing",
]
[[package]]
name = "axum-macros"
version = "0.5.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "604fde5e028fea851ce1d8570bbdc034bec850d157f7569d10f347d06808c05c"
dependencies = [
"proc-macro2",
"quote",
"syn",
]
[[package]]
name = "backtrace"
version = "0.3.76"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "bb531853791a215d7c62a30daf0dde835f381ab5de4589cfe7c649d2cbe92bd6"
dependencies = [
"addr2line",
"cfg-if",
"libc",
"miniz_oxide",
"object",
"rustc-demangle",
"windows-link 0.2.1",
]
[[package]] [[package]]
name = "bimap" name = "bimap"
version = "0.6.3" version = "0.6.3"
@ -96,6 +196,12 @@ dependencies = [
"serde", "serde",
] ]
[[package]]
name = "bytes"
version = "1.11.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "1e748733b7cbc798e1434b6ac524f0c1ff2ab456fe201501e6497c8417a4fc33"
[[package]] [[package]]
name = "cfg-if" name = "cfg-if"
version = "1.0.4" version = "1.0.4"
@ -178,6 +284,27 @@ version = "1.1.0"
source = "registry+https://github.com/rust-lang/crates.io-index" source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "18f12cc9948ed9604230cdddc7c86e270f9401ccbe3c2e98a4378c5e7632212f" checksum = "18f12cc9948ed9604230cdddc7c86e270f9401ccbe3c2e98a4378c5e7632212f"
[[package]]
name = "const_format"
version = "0.2.35"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "7faa7469a93a566e9ccc1c73fe783b4a65c274c5ace346038dca9c39fe0030ad"
dependencies = [
"const_format_proc_macros",
"konst",
]
[[package]]
name = "const_format_proc_macros"
version = "0.2.34"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "1d57c2eccfb16dbac1f4e61e206105db5820c9d26c3c472bc17c774259ef7744"
dependencies = [
"proc-macro2",
"quote",
"unicode-xid",
]
[[package]] [[package]]
name = "displaydoc" name = "displaydoc"
version = "0.2.5" version = "0.2.5"
@ -199,6 +326,7 @@ checksum = "d0881ea181b1df73ff77ffaaf9c7544ecc11e82fba9b5f27b262a3c73a332555"
name = "dynix" name = "dynix"
version = "0.1.0" version = "0.1.0"
dependencies = [ dependencies = [
"axum",
"bimap", "bimap",
"bitflags", "bitflags",
"bstr", "bstr",
@ -206,6 +334,7 @@ dependencies = [
"clap", "clap",
"command-error", "command-error",
"const-str", "const-str",
"const_format",
"displaydoc", "displaydoc",
"fs-err", "fs-err",
"humantime", "humantime",
@ -213,6 +342,7 @@ dependencies = [
"itertools", "itertools",
"libc", "libc",
"mio", "mio",
"parking_lot",
"regex", "regex",
"regex-lite", "regex-lite",
"rustix", "rustix",
@ -220,9 +350,12 @@ dependencies = [
"serde_json", "serde_json",
"sync-fd", "sync-fd",
"tap", "tap",
"tokio",
"tracing", "tracing",
"tracing-human-layer", "tracing-human-layer",
"tracing-subscriber", "tracing-subscriber",
"utoipa",
"utoipa-axum",
"which", "which",
] ]
@ -248,12 +381,27 @@ dependencies = [
"windows-sys 0.61.2", "windows-sys 0.61.2",
] ]
[[package]]
name = "fixedbitset"
version = "0.4.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "0ce7134b9999ecaf8bcd65542e436736ef32ddca1b3e06094cb6ec5755203b80"
[[package]] [[package]]
name = "foldhash" name = "foldhash"
version = "0.2.0" version = "0.2.0"
source = "registry+https://github.com/rust-lang/crates.io-index" source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "77ce24cb58228fbb8aa041425bb1050850ac19177686ea6e0f41a70416f56fdb" checksum = "77ce24cb58228fbb8aa041425bb1050850ac19177686ea6e0f41a70416f56fdb"
[[package]]
name = "form_urlencoded"
version = "1.2.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "cb4cb245038516f5f85277875cdaa4f7d2c9a0fa0468de06ed190163b1581fcf"
dependencies = [
"percent-encoding",
]
[[package]] [[package]]
name = "fs-err" name = "fs-err"
version = "3.3.0" version = "3.3.0"
@ -263,6 +411,45 @@ dependencies = [
"autocfg", "autocfg",
] ]
[[package]]
name = "futures-channel"
version = "0.3.32"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "07bbe89c50d7a535e539b8c17bc0b49bdb77747034daa8087407d655f3f7cc1d"
dependencies = [
"futures-core",
]
[[package]]
name = "futures-core"
version = "0.3.32"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "7e3450815272ef58cec6d564423f6e755e25379b217b0bc688e295ba24df6b1d"
[[package]]
name = "futures-task"
version = "0.3.32"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "037711b3d59c33004d3856fbdc83b99d4ff37a24768fa1be9ce3538a1cde4393"
[[package]]
name = "futures-util"
version = "0.3.32"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "389ca41296e6190b48053de0321d02a77f32f8a5d2461dd38762c0593805c6d6"
dependencies = [
"futures-core",
"futures-task",
"pin-project-lite",
"slab",
]
[[package]]
name = "gimli"
version = "0.32.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "e629b9b98ef3dd8afe6ca2bd0f89306cec16d43d907889945bc5d6687f2f13c7"
[[package]] [[package]]
name = "hashbrown" name = "hashbrown"
version = "0.16.1" version = "0.16.1"
@ -284,12 +471,174 @@ version = "0.5.2"
source = "registry+https://github.com/rust-lang/crates.io-index" source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "fc0fef456e4baa96da950455cd02c081ca953b141298e41db3fc7e36b1da849c" checksum = "fc0fef456e4baa96da950455cd02c081ca953b141298e41db3fc7e36b1da849c"
[[package]]
name = "http"
version = "1.4.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "e3ba2a386d7f85a81f119ad7498ebe444d2e22c2af0b86b069416ace48b3311a"
dependencies = [
"bytes",
"itoa",
]
[[package]]
name = "http-body"
version = "1.0.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "1efedce1fb8e6913f23e0c92de8e62cd5b772a67e7b3946df930a62566c93184"
dependencies = [
"bytes",
"http",
]
[[package]]
name = "http-body-util"
version = "0.1.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "b021d93e26becf5dc7e1b75b1bed1fd93124b374ceb73f43d4d4eafec896a64a"
dependencies = [
"bytes",
"futures-core",
"http",
"http-body",
"pin-project-lite",
]
[[package]]
name = "httparse"
version = "1.10.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "6dbf3de79e51f3d586ab4cb9d5c3e2c14aa28ed23d180cf89b4df0454a69cc87"
[[package]]
name = "httpdate"
version = "1.0.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "df3b46402a9d5adb4c86a0cf463f42e19994e3ee891101b1841f30a545cb49a9"
[[package]] [[package]]
name = "humantime" name = "humantime"
version = "2.3.0" version = "2.3.0"
source = "registry+https://github.com/rust-lang/crates.io-index" source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "135b12329e5e3ce057a9f972339ea52bc954fe1e9358ef27f95e89716fbc5424" checksum = "135b12329e5e3ce057a9f972339ea52bc954fe1e9358ef27f95e89716fbc5424"
[[package]]
name = "hyper"
version = "1.8.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "2ab2d4f250c3d7b1c9fcdff1cece94ea4e2dfbec68614f7b87cb205f24ca9d11"
dependencies = [
"atomic-waker",
"bytes",
"futures-channel",
"futures-core",
"http",
"http-body",
"httparse",
"httpdate",
"itoa",
"pin-project-lite",
"pin-utils",
"smallvec",
"tokio",
]
[[package]]
name = "hyper-util"
version = "0.1.20"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "96547c2556ec9d12fb1578c4eaf448b04993e7fb79cbaad930a656880a6bdfa0"
dependencies = [
"bytes",
"http",
"http-body",
"hyper",
"pin-project-lite",
"tokio",
"tower-service",
]
[[package]]
name = "icu_collections"
version = "2.1.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "4c6b649701667bbe825c3b7e6388cb521c23d88644678e83c0c4d0a621a34b43"
dependencies = [
"displaydoc",
"potential_utf",
"yoke",
"zerofrom",
"zerovec",
]
[[package]]
name = "icu_locale_core"
version = "2.1.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "edba7861004dd3714265b4db54a3c390e880ab658fec5f7db895fae2046b5bb6"
dependencies = [
"displaydoc",
"litemap",
"tinystr",
"writeable",
"zerovec",
]
[[package]]
name = "icu_normalizer"
version = "2.1.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "5f6c8828b67bf8908d82127b2054ea1b4427ff0230ee9141c54251934ab1b599"
dependencies = [
"icu_collections",
"icu_normalizer_data",
"icu_properties",
"icu_provider",
"smallvec",
"zerovec",
]
[[package]]
name = "icu_normalizer_data"
version = "2.1.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "7aedcccd01fc5fe81e6b489c15b247b8b0690feb23304303a9e560f37efc560a"
[[package]]
name = "icu_properties"
version = "2.1.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "020bfc02fe870ec3a66d93e677ccca0562506e5872c650f893269e08615d74ec"
dependencies = [
"icu_collections",
"icu_locale_core",
"icu_properties_data",
"icu_provider",
"zerotrie",
"zerovec",
]
[[package]]
name = "icu_properties_data"
version = "2.1.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "616c294cf8d725c6afcd8f55abc17c56464ef6211f9ed59cccffe534129c77af"
[[package]]
name = "icu_provider"
version = "2.1.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "85962cf0ce02e1e0a629cc34e7ca3e373ce20dda4c4d7294bbd0bf1fdb59e614"
dependencies = [
"displaydoc",
"icu_locale_core",
"writeable",
"yoke",
"zerofrom",
"zerotrie",
"zerovec",
]
[[package]] [[package]]
name = "iddqd" name = "iddqd"
version = "0.3.17" version = "0.3.17"
@ -303,6 +652,27 @@ dependencies = [
"rustc-hash", "rustc-hash",
] ]
[[package]]
name = "idna"
version = "1.1.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "3b0875f23caa03898994f6ddc501886a45c7d3d62d04d2d90788d47be1b1e4de"
dependencies = [
"idna_adapter",
"smallvec",
"utf8_iter",
]
[[package]]
name = "idna_adapter"
version = "1.2.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "3acae9609540aa318d1bc588455225fb2085b9ed0c4f6bd0d9d5bcd86f1a0344"
dependencies = [
"icu_normalizer",
"icu_properties",
]
[[package]] [[package]]
name = "indexmap" name = "indexmap"
version = "2.13.0" version = "2.13.0"
@ -311,6 +681,8 @@ checksum = "7714e70437a7dc3ac8eb7e6f8df75fd8eb422675fc7678aff7364301092b1017"
dependencies = [ dependencies = [
"equivalent", "equivalent",
"hashbrown", "hashbrown",
"serde",
"serde_core",
] ]
[[package]] [[package]]
@ -351,6 +723,21 @@ version = "1.0.17"
source = "registry+https://github.com/rust-lang/crates.io-index" source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "92ecc6618181def0457392ccd0ee51198e065e016d1d527a7ac1b6dc7c1f09d2" checksum = "92ecc6618181def0457392ccd0ee51198e065e016d1d527a7ac1b6dc7c1f09d2"
[[package]]
name = "konst"
version = "0.2.19"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "330f0e13e6483b8c34885f7e6c9f19b1a7bd449c673fbb948a51c99d66ef74f4"
dependencies = [
"konst_macro_rules",
]
[[package]]
name = "konst_macro_rules"
version = "0.2.19"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "a4933f3f57a8e9d9da04db23fb153356ecaf00cbd14aee46279c33dc80925c37"
[[package]] [[package]]
name = "lazy_static" name = "lazy_static"
version = "1.5.0" version = "1.5.0"
@ -369,6 +756,12 @@ version = "0.12.1"
source = "registry+https://github.com/rust-lang/crates.io-index" source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "32a66949e030da00e8c7d4434b251670a91556f4144941d37452769c25d58a53" checksum = "32a66949e030da00e8c7d4434b251670a91556f4144941d37452769c25d58a53"
[[package]]
name = "litemap"
version = "0.8.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "6373607a59f0be73a39b6fe456b8192fcc3585f602af20751600e974dd455e77"
[[package]] [[package]]
name = "lock_api" name = "lock_api"
version = "0.4.14" version = "0.4.14"
@ -376,6 +769,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "224399e74b87b5f3557511d98dff8b14089b3dadafcab6bb93eab67d3aace965" checksum = "224399e74b87b5f3557511d98dff8b14089b3dadafcab6bb93eab67d3aace965"
dependencies = [ dependencies = [
"scopeguard", "scopeguard",
"serde",
] ]
[[package]] [[package]]
@ -393,12 +787,33 @@ dependencies = [
"regex-automata", "regex-automata",
] ]
[[package]]
name = "matchit"
version = "0.8.4"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "47e1ffaa40ddd1f3ed91f717a33c8c0ee23fff369e3aa8772b9605cc1d22f4c3"
[[package]] [[package]]
name = "memchr" name = "memchr"
version = "2.8.0" version = "2.8.0"
source = "registry+https://github.com/rust-lang/crates.io-index" source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "f8ca58f447f06ed17d5fc4043ce1b10dd205e060fb3ce5b979b8ed8e59ff3f79" checksum = "f8ca58f447f06ed17d5fc4043ce1b10dd205e060fb3ce5b979b8ed8e59ff3f79"
[[package]]
name = "mime"
version = "0.3.17"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "6877bb514081ee2a7ff5ef9de3281f14a4dd4bceac4c09388074a6b5df8a139a"
[[package]]
name = "miniz_oxide"
version = "0.8.9"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "1fa76a2c86f704bdb222d66965fb3d63269ce38518b83cb0575fca855ebb6316"
dependencies = [
"adler2",
]
[[package]] [[package]]
name = "mio" name = "mio"
version = "1.1.1" version = "1.1.1"
@ -432,6 +847,15 @@ dependencies = [
"windows-sys 0.61.2", "windows-sys 0.61.2",
] ]
[[package]]
name = "object"
version = "0.37.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "ff76201f031d8863c38aa7f905eca4f53abbfa15f609db4277d44cd8938f33fe"
dependencies = [
"memchr",
]
[[package]] [[package]]
name = "once_cell" name = "once_cell"
version = "1.21.3" version = "1.21.3"
@ -470,19 +894,58 @@ version = "0.9.12"
source = "registry+https://github.com/rust-lang/crates.io-index" source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "2621685985a2ebf1c516881c026032ac7deafcda1a2c9b7850dc81e3dfcb64c1" checksum = "2621685985a2ebf1c516881c026032ac7deafcda1a2c9b7850dc81e3dfcb64c1"
dependencies = [ dependencies = [
"backtrace",
"cfg-if", "cfg-if",
"libc", "libc",
"petgraph",
"redox_syscall", "redox_syscall",
"smallvec", "smallvec",
"windows-link 0.2.1", "windows-link 0.2.1",
] ]
[[package]]
name = "paste"
version = "1.0.15"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "57c0d7b74b563b49d38dae00a0c37d4d6de9b432382b2892f0574ddcae73fd0a"
[[package]]
name = "percent-encoding"
version = "2.3.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "9b4f627cb1b25917193a259e49bdad08f671f8d9708acfd5fe0a8c1455d87220"
[[package]]
name = "petgraph"
version = "0.6.5"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "b4c5cc86750666a3ed20bdaf5ca2a0344f9c67674cae0515bec2da16fbaa47db"
dependencies = [
"fixedbitset",
"indexmap",
]
[[package]] [[package]]
name = "pin-project-lite" name = "pin-project-lite"
version = "0.2.17" version = "0.2.17"
source = "registry+https://github.com/rust-lang/crates.io-index" source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "a89322df9ebe1c1578d689c92318e070967d1042b512afbe49518723f4e6d5cd" checksum = "a89322df9ebe1c1578d689c92318e070967d1042b512afbe49518723f4e6d5cd"
[[package]]
name = "pin-utils"
version = "0.1.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "8b870d8c151b6f2fb93e84a13146138f05d02ed11c7e7c54f8826aaaf7c9f184"
[[package]]
name = "potential_utf"
version = "0.1.4"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "b73949432f5e2a09657003c25bca5e19a0e9c84f8058ca374f49e0ebe605af77"
dependencies = [
"zerovec",
]
[[package]] [[package]]
name = "proc-macro2" name = "proc-macro2"
version = "1.0.106" version = "1.0.106"
@ -557,6 +1020,12 @@ version = "0.8.10"
source = "registry+https://github.com/rust-lang/crates.io-index" source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "dc897dd8d9e8bd1ed8cdad82b5966c3e0ecae09fb1907d58efaa013543185d0a" checksum = "dc897dd8d9e8bd1ed8cdad82b5966c3e0ecae09fb1907d58efaa013543185d0a"
[[package]]
name = "rustc-demangle"
version = "0.1.27"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "b50b8869d9fc858ce7266cce0194bd74df58b9d0e3f6df3a9fc8eb470d95c09d"
[[package]] [[package]]
name = "rustc-hash" name = "rustc-hash"
version = "2.1.1" version = "2.1.1"
@ -576,6 +1045,12 @@ dependencies = [
"windows-sys 0.61.2", "windows-sys 0.61.2",
] ]
[[package]]
name = "ryu"
version = "1.0.23"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "9774ba4a74de5f7b1c1451ed6cd5285a32eddb5cccb8cc655a4e50009e06477f"
[[package]] [[package]]
name = "scopeguard" name = "scopeguard"
version = "1.2.0" version = "1.2.0"
@ -625,6 +1100,29 @@ dependencies = [
"zmij", "zmij",
] ]
[[package]]
name = "serde_path_to_error"
version = "0.1.20"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "10a9ff822e371bb5403e391ecd83e182e0e77ba7f6fe0160b795797109d1b457"
dependencies = [
"itoa",
"serde",
"serde_core",
]
[[package]]
name = "serde_urlencoded"
version = "0.7.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "d3491c14715ca2294c4d6a88f15e84739788c1d030eed8c110436aafdaa2f3fd"
dependencies = [
"form_urlencoded",
"itoa",
"ryu",
"serde",
]
[[package]] [[package]]
name = "sharded-slab" name = "sharded-slab"
version = "0.1.7" version = "0.1.7"
@ -640,6 +1138,22 @@ version = "1.1.1"
source = "registry+https://github.com/rust-lang/crates.io-index" source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "dc6fe69c597f9c37bfeeeeeb33da3530379845f10be461a66d16d03eca2ded77" checksum = "dc6fe69c597f9c37bfeeeeeb33da3530379845f10be461a66d16d03eca2ded77"
[[package]]
name = "signal-hook-registry"
version = "1.4.8"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "c4db69cba1110affc0e9f7bcd48bbf87b3f4fc7c61fc9155afd4c469eb3d6c1b"
dependencies = [
"errno",
"libc",
]
[[package]]
name = "slab"
version = "0.4.12"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "0c790de23124f9ab44544d7ac05d60440adc586479ce501c1d6d7da3cd8c9cf5"
[[package]] [[package]]
name = "smallvec" name = "smallvec"
version = "1.15.1" version = "1.15.1"
@ -652,6 +1166,22 @@ version = "0.3.2"
source = "registry+https://github.com/rust-lang/crates.io-index" source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "b7c388c1b5e93756d0c740965c41e8822f866621d41acbdf6336a6a168f8840c" checksum = "b7c388c1b5e93756d0c740965c41e8822f866621d41acbdf6336a6a168f8840c"
[[package]]
name = "socket2"
version = "0.6.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "3a766e1110788c36f4fa1c2b71b387a7815aa65f88ce0229841826633d93723e"
dependencies = [
"libc",
"windows-sys 0.61.2",
]
[[package]]
name = "stable_deref_trait"
version = "1.2.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "6ce2be8dc25455e1f91df71bfa12ad37d7af1092ae736f3a6cd0e37bc7810596"
[[package]] [[package]]
name = "strsim" name = "strsim"
version = "0.11.1" version = "0.11.1"
@ -697,6 +1227,23 @@ dependencies = [
"libc", "libc",
] ]
[[package]]
name = "sync_wrapper"
version = "1.0.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "0bf256ce5efdfa370213c1dabab5935a12e49f2c58d15e9eac2870d3b4f27263"
[[package]]
name = "synstructure"
version = "0.13.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "728a70f3dbaf5bab7f0c4b1ac8d7ae5ea60a4b5549c8a5914361c99147a709d2"
dependencies = [
"proc-macro2",
"quote",
"syn",
]
[[package]] [[package]]
name = "tap" name = "tap"
version = "1.0.1" version = "1.0.1"
@ -734,12 +1281,80 @@ dependencies = [
"cfg-if", "cfg-if",
] ]
[[package]]
name = "tinystr"
version = "0.8.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "42d3e9c45c09de15d06dd8acf5f4e0e399e85927b7f00711024eb7ae10fa4869"
dependencies = [
"displaydoc",
"zerovec",
]
[[package]]
name = "tokio"
version = "1.50.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "27ad5e34374e03cfffefc301becb44e9dc3c17584f414349ebe29ed26661822d"
dependencies = [
"bytes",
"libc",
"mio",
"parking_lot",
"pin-project-lite",
"signal-hook-registry",
"socket2",
"tokio-macros",
"tracing",
"windows-sys 0.61.2",
]
[[package]]
name = "tokio-macros"
version = "2.6.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "5c55a2eff8b69ce66c84f85e1da1c233edc36ceb85a2058d11b0d6a3c7e7569c"
dependencies = [
"proc-macro2",
"quote",
"syn",
]
[[package]]
name = "tower"
version = "0.5.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "ebe5ef63511595f1344e2d5cfa636d973292adc0eec1f0ad45fae9f0851ab1d4"
dependencies = [
"futures-core",
"futures-util",
"pin-project-lite",
"sync_wrapper",
"tokio",
"tower-layer",
"tower-service",
"tracing",
]
[[package]]
name = "tower-layer"
version = "0.3.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "121c2a6cda46980bb0fcd1647ffaf6cd3fc79a013de288782836f6df9c48780e"
[[package]]
name = "tower-service"
version = "0.3.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "8df9b6e13f2d32c91b9bd719c00d1958837bc7dec474d94952798cc8e69eeec3"
[[package]] [[package]]
name = "tracing" name = "tracing"
version = "0.1.44" version = "0.1.44"
source = "registry+https://github.com/rust-lang/crates.io-index" source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "63e71662fa4b2a2c3a26f570f037eb95bb1f85397f3cd8076caed2f026a6d100" checksum = "63e71662fa4b2a2c3a26f570f037eb95bb1f85397f3cd8076caed2f026a6d100"
dependencies = [ dependencies = [
"log",
"pin-project-lite", "pin-project-lite",
"tracing-attributes", "tracing-attributes",
"tracing-core", "tracing-core",
@ -828,18 +1443,92 @@ version = "0.2.2"
source = "registry+https://github.com/rust-lang/crates.io-index" source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "b4ac048d71ede7ee76d585517add45da530660ef4390e49b098733c6e897f254" checksum = "b4ac048d71ede7ee76d585517add45da530660ef4390e49b098733c6e897f254"
[[package]]
name = "unicode-xid"
version = "0.2.6"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "ebc1c04c71510c7f702b52b7c350734c9ff1295c464a03335b00bb84fc54f853"
[[package]]
name = "url"
version = "2.5.8"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "ff67a8a4397373c3ef660812acab3268222035010ab8680ec4215f38ba3d0eed"
dependencies = [
"form_urlencoded",
"idna",
"percent-encoding",
"serde",
]
[[package]] [[package]]
name = "utf8-command" name = "utf8-command"
version = "1.0.1" version = "1.0.1"
source = "registry+https://github.com/rust-lang/crates.io-index" source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "e4b151524c94cda49046b29e6d20b03092ff9363b02acc1bf3994da60910c55b" checksum = "e4b151524c94cda49046b29e6d20b03092ff9363b02acc1bf3994da60910c55b"
[[package]]
name = "utf8_iter"
version = "1.0.4"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "b6c140620e7ffbb22c2dee59cafe6084a59b5ffc27a8859a5f0d494b5d52b6be"
[[package]] [[package]]
name = "utf8parse" name = "utf8parse"
version = "0.2.2" version = "0.2.2"
source = "registry+https://github.com/rust-lang/crates.io-index" source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "06abde3611657adf66d383f00b093d7faecc7fa57071cce2578660c9f1010821" checksum = "06abde3611657adf66d383f00b093d7faecc7fa57071cce2578660c9f1010821"
[[package]]
name = "utoipa"
version = "5.4.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "2fcc29c80c21c31608227e0912b2d7fddba57ad76b606890627ba8ee7964e993"
dependencies = [
"indexmap",
"serde",
"serde_json",
"utoipa-gen",
]
[[package]]
name = "utoipa-axum"
version = "0.2.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "7c25bae5bccc842449ec0c5ddc5cbb6a3a1eaeac4503895dc105a1138f8234a0"
dependencies = [
"axum",
"paste",
"tower-layer",
"tower-service",
"utoipa",
]
[[package]]
name = "utoipa-config"
version = "0.1.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "06638ae95f08a14f307292bcf2e8ae34b6adbec526190a46a83d27363007a81e"
dependencies = [
"serde",
"serde_json",
]
[[package]]
name = "utoipa-gen"
version = "5.4.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "6d79d08d92ab8af4c5e8a6da20c47ae3f61a0f1dabc1997cdf2d082b757ca08b"
dependencies = [
"once_cell",
"proc-macro2",
"quote",
"regex",
"syn",
"url",
"utoipa-config",
]
[[package]] [[package]]
name = "valuable" name = "valuable"
version = "0.1.1" version = "0.1.1"
@ -1061,6 +1750,89 @@ version = "0.53.1"
source = "registry+https://github.com/rust-lang/crates.io-index" source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "d6bbff5f0aada427a1e5a6da5f1f98158182f26556f345ac9e04d36d0ebed650" checksum = "d6bbff5f0aada427a1e5a6da5f1f98158182f26556f345ac9e04d36d0ebed650"
[[package]]
name = "writeable"
version = "0.6.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "9edde0db4769d2dc68579893f2306b26c6ecfbe0ef499b013d731b7b9247e0b9"
[[package]]
name = "yoke"
version = "0.8.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "72d6e5c6afb84d73944e5cedb052c4680d5657337201555f9f2a16b7406d4954"
dependencies = [
"stable_deref_trait",
"yoke-derive",
"zerofrom",
]
[[package]]
name = "yoke-derive"
version = "0.8.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "b659052874eb698efe5b9e8cf382204678a0086ebf46982b79d6ca3182927e5d"
dependencies = [
"proc-macro2",
"quote",
"syn",
"synstructure",
]
[[package]]
name = "zerofrom"
version = "0.1.6"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "50cc42e0333e05660c3587f3bf9d0478688e15d870fab3346451ce7f8c9fbea5"
dependencies = [
"zerofrom-derive",
]
[[package]]
name = "zerofrom-derive"
version = "0.1.6"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "d71e5d6e06ab090c67b5e44993ec16b72dcbaabc526db883a360057678b48502"
dependencies = [
"proc-macro2",
"quote",
"syn",
"synstructure",
]
[[package]]
name = "zerotrie"
version = "0.2.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "2a59c17a5562d507e4b54960e8569ebee33bee890c70aa3fe7b97e85a9fd7851"
dependencies = [
"displaydoc",
"yoke",
"zerofrom",
]
[[package]]
name = "zerovec"
version = "0.11.5"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "6c28719294829477f525be0186d13efa9a3c602f7ec202ca9e353d310fb9a002"
dependencies = [
"yoke",
"zerofrom",
"zerovec-derive",
]
[[package]]
name = "zerovec-derive"
version = "0.11.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "eadce39539ca5cb3985590102671f2567e659fca9666581ad3411d59207951f3"
dependencies = [
"proc-macro2",
"quote",
"syn",
]
[[package]] [[package]]
name = "zmij" name = "zmij"
version = "1.0.21" version = "1.0.21"

6
Cargo.toml
View file

@ -22,6 +22,7 @@ regex-full = ["dep:regex"]
regex-lite = ["dep:regex-lite"] regex-lite = ["dep:regex-lite"]
[dependencies] [dependencies]
axum = { version = "0.8.8", features = ["macros"] }
bimap = "0.6.3" bimap = "0.6.3"
bitflags = { version = "2.11.0", features = ["std"] } bitflags = { version = "2.11.0", features = ["std"] }
bstr = "1.12.1" bstr = "1.12.1"
@ -29,6 +30,7 @@ circular-buffer = "1.2.0"
clap = { version = "4.5.54", features = ["color", "derive"] } clap = { version = "4.5.54", features = ["color", "derive"] }
command-error = "0.8.0" command-error = "0.8.0"
const-str = "1.1.0" const-str = "1.1.0"
const_format = { version = "0.2.35", features = ["fmt"] }
displaydoc = "0.2.5" displaydoc = "0.2.5"
fs-err = "3.2.2" fs-err = "3.2.2"
humantime = "2.3.0" humantime = "2.3.0"
@ -37,6 +39,7 @@ itertools = "0.14.0"
libc = { version = "0.2.180", features = ["extra_traits"] } libc = { version = "0.2.180", features = ["extra_traits"] }
#macro_rules_attribute = { version = "0.2.2", features = ["better-docs", "verbose-expansions"] } #macro_rules_attribute = { version = "0.2.2", features = ["better-docs", "verbose-expansions"] }
mio = { version = "1.1.1", features = ["os-ext", "os-poll", "net"] } mio = { version = "1.1.1", features = ["os-ext", "os-poll", "net"] }
parking_lot = { version = "0.12.5", features = ["arc_lock", "deadlock_detection", "hardware-lock-elision", "serde"] }
regex = { version = "1.12.3", optional = true } regex = { version = "1.12.3", optional = true }
regex-lite = { version = "0.1.9", optional = true } regex-lite = { version = "0.1.9", optional = true }
rustix = { version = "1.1.4", features = ["event", "fs", "net", "process", "termios"] } rustix = { version = "1.1.4", features = ["event", "fs", "net", "process", "termios"] }
@ -44,9 +47,12 @@ serde = { version = "1.0.228", features = ["derive", "rc"] }
serde_json = "1.0.149" serde_json = "1.0.149"
sync-fd = "0.1.0" sync-fd = "0.1.0"
tap = "1.0.1" tap = "1.0.1"
tokio = { version = "1.50.0", features = ["full", "mio", "tracing"] }
tracing = { version = "0.1.44", features = ["attributes"] } tracing = { version = "0.1.44", features = ["attributes"] }
tracing-human-layer = "0.2.1" tracing-human-layer = "0.2.1"
tracing-subscriber = { version = "0.3.22", default-features = false, features = ["std", "env-filter", "fmt", "ansi", "registry", "parking_lot"] } tracing-subscriber = { version = "0.3.22", default-features = false, features = ["std", "env-filter", "fmt", "ansi", "registry", "parking_lot"] }
utoipa = { version = "5.4.0", features = ["axum_extras", "config", "debug", "indexmap", "preserve_order", "preserve_path_order", "repr", "time", "url"] }
utoipa-axum = { version = "0.2.0", features = ["debug"] }
which = "8.0.2" which = "8.0.2"
[profile.dev] [profile.dev]

76
src/args.rs
View file

@ -3,8 +3,9 @@
// SPDX-License-Identifier: EUPL-1.1 // SPDX-License-Identifier: EUPL-1.1
use std::{ use std::{
env, env, iter,
net::SocketAddr, net::SocketAddr,
ops::Deref,
sync::{Arc, LazyLock}, sync::{Arc, LazyLock},
}; };
@ -26,31 +27,19 @@ pub struct AppendCmd {
#[derive(Debug, Clone, PartialEq, clap::Parser)] #[derive(Debug, Clone, PartialEq, clap::Parser)]
#[command(long_about = None)] #[command(long_about = None)]
pub struct DaemonCmd { pub struct DaemonCmd {
/// Read from stdin instead of a Unix socket. /// Specify the bind address.
#[arg(long)] #[arg(long, default_value = "0.0.0.0:42420")]
pub stdin: bool, pub bind: SocketAddr,
/// Manually specify the full alternative path to the server socket.
///
/// If not specified and `--stdin` is not specified, defaults to $XDG_RUNTIME_DIR/dynix.sock
#[arg(long)]
#[arg(conflicts_with = "stdin")]
pub socket: Option<PathBuf>,
/// Use a TCP port instead of a Unix socket or stdin. e.g.: 0.0.0.0:42420
#[arg(long)]
#[arg(conflicts_with = "socket")]
#[arg(conflicts_with = "stdin")]
pub tcp: Option<SocketAddr>,
} }
#[derive(Debug, Clone, PartialEq, clap::Subcommand)] #[derive(Debug, Clone, PartialEq, clap::Subcommand)]
pub enum Subcommand { pub enum Subcommand {
Append(AppendCmd), Append(AppendCmd),
Daemon(DaemonCmd), Daemon(DaemonCmd),
OpenApiDocs,
} }
static DEFAULT_PATH: LazyLock<Box<OsStr>> = LazyLock::new(|| { pub static DEFAULT_PATH: LazyLock<Arc<Path>> = LazyLock::new(|| {
// This has to be in a let binding to keep the storage around. // This has to be in a let binding to keep the storage around.
let nixos_config = env::var_os("NIXOS_CONFIG"); let nixos_config = env::var_os("NIXOS_CONFIG");
let nixos_config = nixos_config let nixos_config = nixos_config
@ -58,7 +47,7 @@ static DEFAULT_PATH: LazyLock<Box<OsStr>> = LazyLock::new(|| {
.map(Path::new) .map(Path::new)
.unwrap_or(Path::new("/etc/nixos/configuration.nix")); .unwrap_or(Path::new("/etc/nixos/configuration.nix"));
nixos_config let boxed = nixos_config
.parent() .parent()
.unwrap_or_else(|| { .unwrap_or_else(|| {
error!( error!(
@ -67,11 +56,48 @@ static DEFAULT_PATH: LazyLock<Box<OsStr>> = LazyLock::new(|| {
); );
Path::new("/etc/nixos") Path::new("/etc/nixos")
}) })
.join("dynamic.nix") .join("dynamic.nix");
.into_os_string()
.into_boxed_os_str() Arc::from(boxed)
}); });
#[repr(transparent)]
#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub struct DynamicDotNix(pub Arc<Path>);
impl Default for DynamicDotNix {
fn default() -> Self {
DynamicDotNix(Arc::clone(&*DEFAULT_PATH))
}
}
impl From<&str> for DynamicDotNix {
fn from(s: &str) -> DynamicDotNix {
let path = Path::new(s);
let path: PathBuf = if path.is_relative() && !path.starts_with("./") {
iter::once(OsStr::new("./")).chain(path.iter()).collect()
} else {
path.to_path_buf()
};
DynamicDotNix(Arc::from(path))
}
}
impl Display for DynamicDotNix {
fn fmt(&self, f: &mut Formatter) -> FmtResult {
write!(f, "{}", self.0.display())?;
Ok(())
}
}
impl Deref for DynamicDotNix {
type Target = Arc<Path>;
fn deref(&self) -> &Arc<Path> {
&self.0
}
}
#[derive(Debug, Clone, PartialEq, clap::Parser)] #[derive(Debug, Clone, PartialEq, clap::Parser)]
#[command(version, about, author)] #[command(version, about, author)]
#[command(arg_required_else_help(true), args_override_self(true))] #[command(arg_required_else_help(true), args_override_self(true))]
@ -82,9 +108,11 @@ pub struct Args {
/// The .nix file with dynamic overrides to modify. /// The .nix file with dynamic overrides to modify.
/// [default: $(dirname ${NIXOS_CONFIG-/etc/nixos/configuration.nix})/dynamic.nix] /// [default: $(dirname ${NIXOS_CONFIG-/etc/nixos/configuration.nix})/dynamic.nix]
#[arg(long, global(true), default_value = &**DEFAULT_PATH)] #[arg(long, global(true))]
#[arg(default_value_t)]
#[arg(hide_default_value(true))] #[arg(hide_default_value(true))]
pub file: Arc<OsStr>, //#[arg(value_parser = clap::value_parser!(PathBuf))]
pub file: DynamicDotNix,
#[command(subcommand)] #[command(subcommand)]
pub subcommand: Subcommand, pub subcommand: Subcommand,

850
src/daemon.rs
View file

@ -1,67 +1,42 @@
use std::{ use std::{
borrow::Cow,
env, io,
net::SocketAddr, net::SocketAddr,
os::fd::{AsFd, BorrowedFd, IntoRawFd, OwnedFd, RawFd}, process::{Output, Stdio},
process::{Command, Stdio}, sync::LazyLock,
sync::{
Arc, LazyLock,
atomic::{AtomicUsize, Ordering},
},
time::Duration,
}; };
use iddqd::{BiHashMap, IdOrdMap}; use axum::{
Json, Router,
use mio::{ extract::State,
Events, Interest, Poll, Token, http::{self, StatusCode, header::HeaderMap},
event::Event, routing::post,
net::{TcpListener, UnixListener},
unix::SourceFd,
}; };
use tokio::{net::TcpListener, process::Command};
//use utoipa::{OpenApi as _, ToSchema, openapi::OpenApi};
//use utoipa_axum::router::{OpenApiRouter, UtoipaMethodRouterExt};
use rustix::{ use serde::{Deserialize, Serialize};
buffer::spare_capacity,
net::SocketFlags,
process::{Pid, PidfdFlags, Uid, WaitId, WaitIdOptions},
};
mod rustix { use crate::{SourceFile, prelude::*};
pub use rustix::process::waitid;
pub use rustix::*;
}
//mod rustix_prelude {
// pub use rustix::process::{getuid, pidfd_open, waitid};
//}
use serde_json::StreamDeserializer;
use crate::prelude::*;
pub mod api; pub mod api;
use api::DaemonCmd; use api::{ConvenientAttrPath, NixLiteral};
use crate::daemon_tokfd::{FdInfo, FdKind}; //pub static UID: LazyLock<Uid> = LazyLock::new(rustix::process::getuid);
use crate::{OwnedFdWithFlags, TokenFd}; //pub static USER_SOCKET_DIR: LazyLock<&'static Path> = LazyLock::new(|| {
// let dir: Box<Path> = env::var_os("XDG_RUNTIME_DIR")
// .map(PathBuf::from)
// .unwrap_or_else(|| ["/", "run", "user", &UID.to_string()].into_iter().collect())
// .into_boxed_path();
//
// Box::leak(dir)
//});
pub static UID: LazyLock<Uid> = LazyLock::new(rustix::process::getuid); //pub static TMPDIR: LazyLock<&'static Path> = LazyLock::new(|| {
// let dir: Box<Path> = env::temp_dir().into_boxed_path();
pub static USER_SOCKET_DIR: LazyLock<&'static Path> = LazyLock::new(|| { //
let dir: Box<Path> = env::var_os("XDG_RUNTIME_DIR") // Box::leak(dir)
.map(PathBuf::from) //});
.unwrap_or_else(|| ["/", "run", "user", &UID.to_string()].into_iter().collect())
.into_boxed_path();
Box::leak(dir)
});
pub static TMPDIR: LazyLock<&'static Path> = LazyLock::new(|| {
let dir: Box<Path> = env::temp_dir().into_boxed_path();
Box::leak(dir)
});
pub static NIX: LazyLock<&'static Path> = LazyLock::new(|| { pub static NIX: LazyLock<&'static Path> = LazyLock::new(|| {
which::which("nix") which::which("nix")
@ -71,388 +46,154 @@ pub static NIX: LazyLock<&'static Path> = LazyLock::new(|| {
.unwrap_or(Path::new("/run/current-system/sw/bin/nix")) .unwrap_or(Path::new("/run/current-system/sw/bin/nix"))
}); });
const TIMEOUT_NEVER: Option<Duration> = None; pub async fn run(config: Config) {
let addr = config.addr.clone();
let router = Router::new()
.route("/set", post(ep_set_post))
// `.with_state()` has to be last for the type inference to work.
.with_state(config);
//let (router, api): (Router, OpenApi) = OpenApiRouter::with_openapi(ApiDoc::openapi())
// .routes(utoipa_axum::routes!(ep_set_post))
// // `.with_state()` has to be last for the type inference works.
// .with_state(config)
// .split_for_parts();
static NEXT_TOKEN_NUMBER: AtomicUsize = AtomicUsize::new(1); let listener = TcpListener::bind(addr).await.unwrap();
fn next_token() -> Token {
let tok = NEXT_TOKEN_NUMBER.fetch_add(1, Ordering::SeqCst);
// If the increment wrapped to 0, then we just increment it again. axum::serve(listener, router).await.unwrap();
if tok == 0 {
warn!("File descriptor token wrapped. That's... a lot.");
return next_token();
} }
Token(tok) #[derive(Debug, Clone)]
pub struct Config {
pub config_file: SourceFile,
pub addr: SocketAddr,
pub token: Option<String>,
} }
#[derive(Debug)] #[derive(Debug, Clone, PartialEq, PartialOrd)]
pub struct Daemon { #[derive(Deserialize, Serialize)]
config_path: Arc<Path>, //#[derive(ToSchema)]
fd: OwnedFdWithFlags, pub struct SetParams {
path: Option<Box<Path>>, pub name: ConvenientAttrPath,
pub value: NixLiteral,
poller: Poll,
fd_info: IdOrdMap<FdInfo>,
// Bijective mapping of [`mio::Token`]s to [`RawFd`]s.
tokfd: BiHashMap<TokenFd>,
} }
/// `tokfd` handling. #[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
impl Daemon { #[derive(Deserialize, Serialize)]
fn fd_error_pop(&mut self, fd: RawFd) -> Option<IoError> { //#[derive(ToSchema)]
let mut info = self.fd_info.get_mut(&fd).unwrap_or_else(|| { pub struct SetResponse {
if let Ok(name) = FdInfo::guess_name(fd) { /// Will be 0 if everything is okay.
panic!(
"tried to pop error for unknown fd {fd} ({})",
name.to_string_lossy(),
);
}
panic!("tried to pop error for unknown fd {fd}")
});
info.error_buffer.pop_front().tap_some(|e| {
trace!("Popping error for {}: {e}", info.display());
})
}
fn fd_error_push(&mut self, fd: RawFd, error: IoError) -> Result<(), IoError> {
let mut info = self
.fd_info
.get_mut(&fd)
.unwrap_or_else(|| panic!("tried to push error for unknown fd {fd}"));
trace!("Pushing error for {}: {}", info.display(), error);
info.error_buffer.try_push_back(error)
}
fn main_fd_info(&self) -> &FdInfo {
self.fd_info.get(&self.fd.as_raw_fd()).unwrap_or_else(|| {
unreachable!(
"Main daemon fd {:?} was not registered with fd_info",
self.fd,
)
})
}
fn register(&mut self, fd: RawFd, kind: FdKind) -> Token {
let token = next_token();
debug!(
"Registering new {} FdInfo for {fd} with token {token:?}",
kind.name_str(),
);
self.fd_info.insert_unique(FdInfo::new(fd, kind)).unwrap();
self.tokfd
.insert_unique(TokenFd { token, fd })
.unwrap_or_else(|e| todo!("{e}"));
let mut source = SourceFd(&fd);
self.poller
.registry()
.register(&mut source, token, Interest::READABLE)
.unwrap_or_else(|e| unreachable!("registering {fd:?} with poller failed: {e}"));
token
}
#[expect(dead_code)]
fn register_with_name<S>(&mut self, fd: RawFd, kind: FdKind, name: Box<OsStr>) -> Token {
let token = next_token();
debug!(
"Registering new {} FdInfo for {fd} ({}) with token {token:?}",
name.to_string_lossy(),
kind.name_str(),
);
self.fd_info
.insert_unique(FdInfo::new_with_name(fd, kind, name))
.unwrap();
self.tokfd
.insert_unique(TokenFd { token, fd })
.unwrap_or_else(|e| todo!("{e}"));
let mut source = SourceFd(&fd);
self.poller
.registry()
.register(&mut source, token, Interest::READABLE)
.unwrap_or_else(|e| unreachable!("registering {fd:?} with poller failed: {e}"));
token
}
fn deregister(&mut self, fd: RawFd) {
let info = self
.fd_info
.remove(&fd)
.unwrap_or_else(|| unreachable!("tried to unregister unknown fd {fd}"));
debug!("Unregistering fd {}; calling close()", info.display());
unsafe { rustix::io::close(fd) };
let res = unsafe { libc::fcntl(fd, libc::F_GETFD, 0) };
debug_assert_eq!(res, -1);
debug_assert_eq!(
IoError::last_os_error().raw_os_error(),
Some(Errno::BADF.raw_os_error()),
);
self.tokfd.remove2(&fd).unwrap_or_else(|| todo!());
}
fn fd_for_token(&self, token: Token) -> Option<RawFd> {
self.tokfd
.get1(&token)
.map(|TokenFd { fd, .. }| fd)
.copied()
}
/// Not currently used, but here for completeness.
#[expect(dead_code)]
fn token_for_fd(&self, fd: RawFd) -> Option<Token> {
self.tokfd
.get2(&fd)
.map(|TokenFd { token, .. }| token)
.copied()
}
}
impl Daemon {
pub fn new(
config_path: Arc<Path>,
fd: OwnedFd,
kind: FdKind,
name: Option<Box<OsStr>>,
) -> Self {
let mut fd_info: IdOrdMap<FdInfo> = Default::default();
// Supposedly, the only possible ways this can fail are EMFILE, ENFILE, and ENOMEM.
// If any of those are the case, we're screwed anyway.
let poller = Poll::new().unwrap_or_else(|e| panic!("can't create new mio::Poll: {e}"));
// Make sure we register the poller in `fd_info`, so we can keep track of its errors.
fd_info
.insert_unique(FdInfo::new(poller.as_raw_fd(), FdKind::Poller))
.unwrap_or_else(|e| unreachable!("{e}"));
let fd = OwnedFdWithFlags::new_with_fallback(fd);
fd_info
.insert_unique(FdInfo::new(fd.as_raw_fd(), kind))
.unwrap_or_else(|e| unreachable!("{e}"));
if let Some(name) = &name {
info!("opened daemon to {}", name.to_string_lossy());
} else {
debug!("opened daemon to {name:?} (fd {fd:?})");
}
let path = name
.as_ref()
.map(PathBuf::from)
.map(PathBuf::into_boxed_path);
Self {
config_path,
fd,
path,
poller,
fd_info,
tokfd: Default::default(),
}
}
pub fn from_tcp_socket_addr(config_path: Arc<Path>, addr: SocketAddr) -> Result<Self, IoError> {
let listener = TcpListener::bind(addr.clone())
.inspect_err(|e| error!("failed to bind to '{addr}': {e}"))?;
let listener_owned_fd = OwnedFd::from(listener);
// FIXME: should we KEEP_ALIVE?
rustix::net::sockopt::set_socket_keepalive(&listener_owned_fd, true).unwrap();
let name = OsString::from(addr.to_string()).into_boxed_os_str();
Ok(Self::new(
config_path,
listener_owned_fd,
FdKind::Socket,
Some(name),
))
}
pub fn from_unix_socket_path(config_path: Arc<Path>, path: &Path) -> Result<Self, IoError> {
// We unconditionally unlink() `path` before binding, but completely ignore the result.
let _ = rustix::fs::unlink(path);
let listener = UnixListener::bind(path)
.tap_err(|e| error!("failed to bind AF_UNIX socket at {}: {e}", path.display()))?;
let listener_owned_fd = OwnedFd::from(listener);
// FIXME: should we KEEP_ALIVE?
rustix::net::sockopt::set_socket_keepalive(&listener_owned_fd, true).unwrap();
let path: Box<OsStr> = path.to_path_buf().into_boxed_path().into_boxed_os_str();
Ok(Self::new(
config_path,
listener_owned_fd,
FdKind::Socket,
Some(path),
))
}
pub fn open_default_socket(config_path: Arc<Path>) -> Result<Self, IoError> {
use IoErrorKind::*;
let preferred = USER_SOCKET_DIR.join("dynix.sock").into_boxed_path();
let constructed = match Self::from_unix_socket_path(config_path.clone(), &preferred) {
Ok(v) => v,
Err(e) if e.kind() == Unsupported => {
//
return Err(e);
},
Err(e) => {
warn!(
"failed binding AF_UNIX socket at {}: {e}; trying elsewhere",
preferred.display(),
);
let fallback = TMPDIR.join("dynix.sock").into_boxed_path();
Self::from_unix_socket_path(config_path, &fallback).tap_err(|e| {
error!(
"failed binding AF_UNIX socket at {}: {e}",
fallback.display(),
)
})?
},
};
Ok(constructed)
}
/// This panics if stdin cannot be opened.
/// ///
/// If you want to handle that error, use [`Daemon::from_raw_parts()`]. /// Will be -1 for an error with no code.
pub fn from_stdin(config_path: Arc<Path>) -> Self { pub status: i64,
let stdin = io::stdin(); pub msg: Option<String>,
let fd = stdin
.as_fd()
.try_clone_to_owned()
.expect("dynix daemon could not open stdin; try a Unix socket?");
Self::new(config_path, fd, FdKind::File, None)
} }
//pub unsafe fn from_raw_parts(fd: OwnedFd) -> Self { #[axum::debug_handler]
// Self { //#[utoipa::path(
// fd: OwnedFdWithFlags::new_with_fallback(fd), // post,
// } // path = "/set",
//} // responses(
// (status = 200, description = "Request was valid", body = SetResponse)
// ),
//)]
async fn ep_set_post(
State(config): State<Config>,
headers: HeaderMap,
Json(SetParams { name, value }): Json<SetParams>,
) -> Result<Json<SetResponse>, StatusCode> {
debug!("POST /set with name={name:?}, value={value:?}");
pub fn fd(&self) -> BorrowedFd<'_> { if let Some(token) = &config.token {
self.fd.as_fd() let Some(auth) = headers.get(http::header::AUTHORIZATION) else {
} // FIXME: technically RFC9110 requires us to respond with a
} // `WWW-Authenticate` header.
const DAEMON: Token = Token(0); error!("token specified in config but not provided in request");
return Err(StatusCode::UNAUTHORIZED);
/// Private helpers.
impl Daemon {
fn proxy_stdio(&mut self, fd: &BorrowedFd) -> Result<(), IoError> {
let info = self.fd_info.get(&fd.as_raw_fd()).unwrap();
let label = match info.kind {
FdKind::ChildStdout(pid) => format!("stdout[{pid}]"),
FdKind::ChildStderr(pid) => format!("stderr[{pid}]"),
other => unreachable!("child stdio cannot have kind {other:?}"),
}; };
// FIXME: don't use a new allocation every time. // No need to go through UTF-8 decoding here.
let mut buffer: Vec<u8> = Vec::with_capacity(1024); if auth.as_bytes() != token.as_bytes() {
// FIXME: handle line buffering correctly. error!("token provided in request does not match configured token");
loop { return Err(StatusCode::UNAUTHORIZED);
let count = rustix::io::read(fd, spare_capacity(&mut buffer))
.inspect_err(|e| error!("read() on child stdio fd {fd:?} failed: {e}"))?;
if count == 0 {
break;
}
for line in buffer.lines() {
info!("[child {label}]: {}", line.as_bstr())
} }
} }
Ok(()) let file = config.config_file.clone();
}
fn read_cmd(&mut self, fd: &BorrowedFd) -> Result<(), IoError> { let prio = crate::get_where(file.clone());
// FIXME: don't use a new allocation every time. let new_prio = prio - 1;
let mut cmd_buffer: Vec<u8> = Vec::with_capacity(1024);
let _count = rustix::io::read(fd, spare_capacity(&mut cmd_buffer))
.tap_err(|e| error!("read() on daemon fd {fd:?} failed: {e}"))?;
// The buffer might have existing data from the last read.
let deserializer = serde_json::Deserializer::from_slice(&cmd_buffer);
let stream: StreamDeserializer<_, DaemonCmd> = deserializer.into_iter();
for cmd in stream {
let cmd = match cmd {
Ok(cmd) => cmd,
Err(e) if e.is_eof() => {
warn!("Got EOF before a valid command");
debug!("command buffer was: {:?}", cmd_buffer.as_bstr());
return Ok(());
},
Err(e) => {
warn!("error deserializing command: {e}");
debug!("command buffer was: {:?}", cmd_buffer.as_bstr());
// Don't propagate the error unless we have too many.
self.fd_error_push(fd.as_raw_fd(), e.into()).tap_err(|e| {
error!("Accumulated too many errors for daemon fd {fd:?}: {e}")
})?;
return Ok(());
},
};
debug!("got cmd: {cmd:?}");
let _ = rustix::io::write(fd, b"");
info!("dispatching command {cmd:?}");
self.dispatch_cmd(cmd).unwrap_or_else(|e| todo!("{e}"));
}
Ok(())
}
fn dispatch_cmd(&mut self, cmd: DaemonCmd) -> Result<(), IoError> {
// Write the new file...
let (name, value) = match cmd {
DaemonCmd::Append { name, value } => (name, value),
};
let source_file = crate::open_source_file(self.config_path.clone())?;
let pri = crate::get_where(source_file.clone()).unwrap_or_else(|e| todo!("{e}"));
let new_pri = pri - 1;
// Get next priority line.
let opt_name = name.to_nix_decl(); let opt_name = name.to_nix_decl();
let new_line = crate::get_next_prio_line( let opt_val = value.to_nix_source();
source_file.clone(), let new_line = crate::get_next_prio_line(file.clone(), &opt_name, new_prio, &opt_val);
&opt_name,
new_pri,
&value.to_nix_source(),
)
.unwrap_or_else(|e| panic!("someone is holding a reference to source.lines(): {e}"));
crate::write_next_prio(source_file, new_line).unwrap_or_else(|e| todo!("{e}")); match crate::write_next_prio(file.clone(), new_line) {
Ok(()) => (),
Err(e) => {
error!("Couldn't write next generation to {}: {e}", file.display());
let status = e.raw_os_error().map(i64::from).unwrap_or(-1);
return Ok(Json(SetResponse {
status,
msg: Some(format!("{e}")),
}));
},
};
// Rebuild and switch. let child_status = match nix_run_apply(&config).await {
// FIXME: allow passing additional args. Ok(v) => v,
//let child = Command::new(*NIXOS_REBUILD) Err(e) => {
// .arg("switch") let status = e.raw_os_error().map(i64::from).unwrap_or(-1);
// .arg("--log-format") return Ok(Json(SetResponse {
// .arg("raw-with-logs") status,
// .arg("--no-reexec") msg: Some(format!("{e}")),
// .arg("-v") }));
// .stdout(Stdio::piped()) },
// .stderr(Stdio::piped()) };
// .spawn()
// .inspect_err(|e| { let Output {
// error!("failed to spawn `nixos-rebuild` command: {e}"); status,
// })?; stdout,
stderr,
} = child_status;
if status.code() != Some(0) {
error!(
"Child `nix run` process returned non-zero code {:?}",
status.code(),
);
error!("Child stdout: {}", stdout.as_bstr());
error!("Child stderr: {}", stderr.as_bstr());
}
let status = status.code().map(i64::from).unwrap_or(-1);
let msg = format!(
"Stdout: {}\nStderr: {}\n",
stdout.as_bstr(),
stderr.as_bstr()
);
Ok(Json(SetResponse {
status,
msg: Some(msg),
}))
}
async fn nix_run_apply(config: &Config) -> Result<Output, IoError> {
let configuration_nix = config
.config_file
.path()
.parent()
.unwrap()
.join("configuration.nix");
let configuration_nix = configuration_nix
.to_str()
.expect("specified NixOS config file is not a UTF-8 path");
let expr = format!(
"(import <nixpkgs/nixos> {{ configuration = {}; }})\
.config.dynamicism.applyDynamicConfiguration {{ baseConfiguration = {}; }}",
configuration_nix, configuration_nix,
);
let expr = "(import <nixpkgs/nixos> { }).config.dynamicism.applyDynamicConfiguration { }";
let child = Command::new(*NIX) let child = Command::new(*NIX)
.arg("run") .arg("run")
.arg("--show-trace") .arg("--show-trace")
@ -461,277 +202,30 @@ impl Daemon {
.arg("--impure") .arg("--impure")
.arg("-E") .arg("-E")
.arg(expr) .arg(expr)
.tap(|cmd| {
if !tracing::enabled!(Level::INFO) {
return;
}
let args: Vec<Cow<'_, str>> = cmd.get_args().map(OsStr::to_string_lossy).collect();
let separated = args.join(" ");
info!("Spawning subprocess: [{separated}]");
})
.stdout(Stdio::piped()) .stdout(Stdio::piped())
.stderr(Stdio::piped()) .stderr(Stdio::piped())
.tap(|cmd| {
if tracing::enabled!(Level::DEBUG) {
let args = cmd
.as_std()
.get_args()
.map(OsStr::to_string_lossy)
.join(" ");
debug!("Spawning command: `nix {args}`");
}
})
.spawn() .spawn()
.inspect_err(|e| error!("failed to spawn `nix run` command: {e}"))?; .inspect_err(|e| error!("error spawning command: {e}"))?;
debug!("Spanwed child process {}", child.id()); let output = child.wait_with_output().await.inspect_err(|e| {
error!("couldn't wait for spawned child process: {e}");
let pid = Pid::from_child(&child);
let stdout = child.stdout.unwrap_or_else(|| {
unreachable!("`child` is given `.stdout(Stdio::piped())`");
});
let stderr = child.stderr.unwrap_or_else(|| {
unreachable!("`child` is given `.stderr(Stdio::piped())`");
});
let _token = self.register(stdout.into_raw_fd(), FdKind::ChildStdout(pid));
let _token = self.register(stderr.into_raw_fd(), FdKind::ChildStderr(pid));
match rustix::process::pidfd_open(pid, PidfdFlags::NONBLOCK) {
Ok(pidfd) => {
debug!("Opened pidfd {pidfd:?}, for process {pid}");
self.register(pidfd.into_raw_fd(), FdKind::Pid(pid));
},
Err(e) if e.kind() == IoErrorKind::NotFound => {
warn!("child {pid} not found; died before we could open it?");
},
Err(e) => {
error!("Error opening pidfd for child {pid}: {e}");
return Err(e)?;
},
}
Ok(())
}
pub(crate) fn enter_loop(&mut self) -> Result<Option<()>, IoError> {
let raw_fd = self.fd.as_raw_fd();
if cfg!(debug_assertions) {
assert!(
self.fd_info.contains_key(&raw_fd),
"we should know about daemon fd {raw_fd}",
);
assert!(
self.fd_info.contains_key(&self.poller.as_raw_fd()),
"we should know about poller fd {}",
self.poller.as_raw_fd(),
);
}
let mut daemon_source = SourceFd(&raw_fd);
self.tokfd
.insert_unique(TokenFd {
token: DAEMON,
fd: raw_fd,
})
.unwrap();
self.poller
.registry()
.register(&mut daemon_source, DAEMON, Interest::READABLE)
.unwrap_or_else(|e| unreachable!("registering mio Poll for daemon fd {raw_fd:?}: {e}"));
let mut events = Events::with_capacity(1024);
loop {
if tracing::enabled!(tracing::Level::DEBUG) {
debug!("Daemon loop iteration, with file descriptors: ");
for info in &self.fd_info {
debug!("- {}", info.display());
}
}
let poll_result = self.poller.poll(&mut events, TIMEOUT_NEVER);
self.handle_poll(poll_result, &events)?;
}
}
fn handle_poll(
&mut self,
poll_result: Result<(), IoError>,
events: &Events,
) -> Result<(), IoError> {
match poll_result {
Ok(()) => {
trace!(
"mio::Poller::poll() got events: {:?}",
events.iter().size_hint().0,
);
if events.is_empty() {
unreachable!(
"epoll_wait() with a \"forever\" timeout should never give empty events",
);
}
let _ = self.fd_error_pop(self.poller.as_raw_fd());
},
Err(e) if e.kind() == IoErrorKind::Interrupted => {
// EINTR is silly.
// Return early, and poll() again.
return Ok(());
},
Err(e) => {
if let Some(Errno::BADF) = e.raw_os_error().map(Errno::from_raw_os_error) {
panic!("EBADF on poller fd; IO safety violation?");
}
warn!("mio Poll::poll() error: {e}");
self.fd_error_push(self.poller.as_raw_fd(), e)
.tap_err(|e| {
error!("accumulated too many errors for mio::Poll::poll(): {e}")
})?;
},
}
for event in events {
self.handle_event(event)?;
}
Ok(())
}
fn handle_event(&mut self, event: &Event) -> Result<(), IoError> {
trace!("Handling event {event:#?}");
match event.token() {
DAEMON => {
let is_sock = self.main_fd_info().kind == FdKind::Socket;
if !is_sock {
// SAFETY: oh boy: disjoint borrows with extra steps.
let file_fd = unsafe { BorrowedFd::borrow_raw(self.fd.as_raw_fd()) };
self.read_cmd(&file_fd).unwrap();
return Ok(());
}
// Accept, first.
let flags = SocketFlags::NONBLOCK | SocketFlags::CLOEXEC;
let stream_fd = match rustix::net::accept_with(&self.fd, flags) {
Ok(stream) => {
debug!(
"Accepted connection from socket {:?} as stream {:?}",
self.fd, stream,
);
stream
},
Err(e) => {
error!("accept4 on daemon socket failed: {e}");
self.fd_error_push(self.fd.as_raw_fd(), e.into())
.tap_err(|e| {
error!(
"Accumulated too many errors for daemon fd {:?}: {e}",
self.fd
)
})?; })?;
return Ok(()); Ok(output)
},
};
// Add this stream to our poll interest list.
// NOTE: `stream_fd` is now effectively `ManuallyDrop`.
let stream_fd = stream_fd.into_raw_fd();
let _token = self.register(stream_fd, FdKind::SockStream);
// Wait for the next poll to handle.
},
other_token => {
// This must be a stream fd.
let fd = self.fd_for_token(other_token).unwrap_or_else(|| {
unreachable!("tried to get fd for non-existent token? {other_token:?}")
});
let Some(info) = self.fd_info.get(&fd) else {
panic!("Received an event on an unregistered fd {fd}; IO-safety violation?");
};
let either_available = event.is_readable() || event.is_writable();
if !either_available {
info!(
"Got EVENT for file descriptor '{}': r={}, w={}",
info.display(),
event.is_readable(),
event.is_writable(),
);
// FIXME: code duplication
if event.is_read_closed() {
self.deregister(fd);
return Ok(());
}
} }
match info.kind { //#[derive(Copy)]
FdKind::Pid(pid) => { //#[derive(Debug, Clone, PartialEq)]
debug!("Reaping child process {pid}"); //#[derive(utoipa::OpenApi)]
// SAFETY: `fd` cannot have been closed yet, since that's what we do here. //#[openapi(paths(ep_set_post))]
let pidfd = unsafe { BorrowedFd::borrow_raw(fd) }; //pub struct ApiDoc;
let status = rustix::waitid(WaitId::PidFd(pidfd), WaitIdOptions::EXITED)
.unwrap_or_else(|e| {
todo!("waitid() can fail? on pid {pid}: {e}");
})
.unwrap_or_else(|| {
todo!("waitid() returned None? for pid {pid}");
});
trace!("waitid() for pid {pid} returned status: {status:?}");
let is_dead = status.exited() || status.killed() || status.dumped();
if !is_dead {
todo!("Handle process {pid} events that aren't death: {status:?}");
}
let Some(exit_code) = status.exit_status() else {
unreachable!("Process {pid} died with no exit code at all? {status:?}");
};
debug!("Child process {pid} exited with code {exit_code}");
// Close the pidfd.
self.deregister(fd);
let stream = self
.fd_info
.iter()
.find_map(|info| (info.kind == FdKind::SockStream).then_some(info));
if let Some(stream) = stream {
// SAFETY: fixme.
let stream_fd = unsafe { BorrowedFd::borrow_raw(stream.fd) };
let payload = format!("{{ \"status\": {exit_code} }}\n");
if let Err(e) = rustix::io::write(stream_fd, payload.as_bytes()) {
error!("couldn't write reply to stream fd {stream_fd:?}: {e}");
}
}
},
FdKind::ChildStdout(_pid) => {
// SAFETY: oh boy.
let stdout = unsafe { BorrowedFd::borrow_raw(fd) };
self.proxy_stdio(&stdout)
.unwrap_or_else(|e| error!("failed to proxy child stdout: {e}"));
},
FdKind::ChildStderr(_pid) => {
// SAFETY: oh boy.
let stderr = unsafe { BorrowedFd::borrow_raw(fd) };
self.proxy_stdio(&stderr)
.unwrap_or_else(|e| error!("failed to proxy child stderr: {e}"));
},
FdKind::SockStream => {
// SAFETY: oh boy.
let stream_fd = unsafe { BorrowedFd::borrow_raw(fd) };
self.read_cmd(&stream_fd).unwrap();
},
kind => todo!("{kind:?}"),
};
if event.is_read_closed() {
self.deregister(fd);
return Ok(());
}
},
}
Ok(())
}
}
impl Drop for Daemon {
fn drop(&mut self) {
if let Some(path) = self.path.as_deref() {
let _ = rustix::fs::unlink(path);
}
}
}

7
src/daemon/api.rs
View file

@ -3,6 +3,7 @@ use std::ops::Deref;
use crate::prelude::*; use crate::prelude::*;
use serde::{Deserialize, Serialize}; use serde::{Deserialize, Serialize};
use utoipa::ToSchema;
mod impls; mod impls;
@ -11,6 +12,7 @@ mod impls;
/// This type does not provide a [`Default`] impl, however. /// This type does not provide a [`Default`] impl, however.
#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)] #[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[derive(Deserialize, Serialize)] #[derive(Deserialize, Serialize)]
#[derive(ToSchema)]
#[serde(untagged)] #[serde(untagged)]
pub enum ConvenientAttrPath { pub enum ConvenientAttrPath {
Dotted(Box<str>), Dotted(Box<str>),
@ -47,8 +49,9 @@ impl ConvenientAttrPath {
} }
} }
#[derive(Debug, Clone, PartialEq)] #[derive(Debug, Clone, PartialEq, PartialOrd)]
#[derive(Deserialize, Serialize)] #[derive(Deserialize, Serialize)]
#[derive(ToSchema)]
#[serde(untagged)] #[serde(untagged)]
pub enum NixLiteral { pub enum NixLiteral {
String(String), String(String),
@ -70,7 +73,7 @@ impl NixLiteral {
#[serde(tag = "action", content = "args", rename_all = "snake_case")] #[serde(tag = "action", content = "args", rename_all = "snake_case")]
// FIXME: rename to not confuse with the clap argument type. // FIXME: rename to not confuse with the clap argument type.
pub enum DaemonCmd { pub enum DaemonCmd {
Append { Set {
name: ConvenientAttrPath, name: ConvenientAttrPath,
value: Box<NixLiteral>, value: Box<NixLiteral>,
}, },

184
src/daemon_tokfd.rs
View file

@ -1,184 +0,0 @@
use std::{os::fd::RawFd, sync::OnceLock};
use circular_buffer::CircularBuffer;
use iddqd::{BiHashItem, IdOrdItem};
use mio::Token;
use rustix::process::Pid;
use crate::prelude::*;
const ERROR_BUFFER_LEN: usize = 8;
#[derive(Debug)]
pub struct FdInfo {
pub fd: RawFd,
pub kind: FdKind,
pub name: OnceLock<Box<OsStr>>,
pub error_buffer: CircularBuffer<ERROR_BUFFER_LEN, IoError>,
}
impl FdInfo {
pub fn new<Fd: AsRawFd>(fd: Fd, kind: FdKind) -> Self {
Self {
fd: fd.as_raw_fd(),
kind,
name: Default::default(),
error_buffer: Default::default(),
}
}
pub fn new_with_name<Fd: AsRawFd>(fd: Fd, kind: FdKind, name: Box<OsStr>) -> Self {
Self {
fd: fd.as_raw_fd(),
kind,
name: OnceLock::from(name),
error_buffer: Default::default(),
}
}
}
impl FdInfo {
pub(crate) fn guess_name<Fd: AsRawFd>(fd: Fd) -> Result<Box<OsStr>, IoError> {
let dev_fd_path = Path::new("/dev/fd").join(fd.as_raw_fd().to_string());
fs_err::read_link(dev_fd_path)
.map(PathBuf::into_os_string)
.map(OsString::into_boxed_os_str)
}
pub fn name(&self) -> &OsStr {
if let Some(name) = self.name.get() {
return name;
}
match Self::guess_name(self.fd) {
Ok(name) => {
let prev = self.name.set(name);
debug_assert_eq!(prev, Ok(()));
},
Err(e) => {
warn!(
"can't read link for {} /dev/fd/{}: {e}",
self.kind.name_str(),
self.fd,
);
return OsStr::new("«unknown»");
},
}
self.name.get().unwrap_or_else(|| unreachable!())
}
pub fn display(&self) -> FdInfoDisplay<'_> {
FdInfoDisplay { inner: self }
}
}
impl IdOrdItem for FdInfo {
type Key<'a> = &'a RawFd;
iddqd::id_upcast!();
fn key(&self) -> &RawFd {
&self.fd
}
}
#[derive(Debug)]
pub struct FdInfoDisplay<'a> {
inner: &'a FdInfo,
}
impl<'a> Display for FdInfoDisplay<'a> {
fn fmt(&self, f: &mut Formatter) -> FmtResult {
write!(
f,
"{} fd {} ({})",
self.inner.kind,
self.inner.fd,
self.inner.name().to_string_lossy(),
)?;
if !self.inner.error_buffer.is_empty() {
write!(f, "; with errors: {}", self.inner.error_buffer.len())?;
}
Ok(())
}
}
#[derive(Copy)]
#[derive(Debug, Clone, PartialEq, Eq, Hash, Default)]
#[non_exhaustive]
pub enum FdKind {
File,
Socket,
SockStream,
Poller,
ChildStdout(Pid),
ChildStderr(Pid),
Pid(Pid),
#[default]
Unknown,
}
impl FdKind {
pub fn name_str(self) -> &'static str {
use FdKind::*;
match self {
File => "file",
Socket => "socket",
SockStream => "socket stream",
Poller => "poller",
ChildStdout(_) => "child stdout",
ChildStderr(_) => "child stderr",
Pid(_) => "pidfd",
Unknown => "«unknown»",
}
}
}
impl Display for FdKind {
fn fmt(&self, f: &mut Formatter) -> FmtResult {
use FdKind::*;
let name = self.name_str();
match self {
ChildStdout(pid) | ChildStderr(pid) | Pid(pid) => write!(f, "{name} for {pid}")?,
_ => write!(f, "{name}")?,
};
Ok(())
}
}
#[derive(Copy)]
#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub struct TokenFd {
pub token: Token,
pub fd: RawFd,
}
impl BiHashItem for TokenFd {
type K1<'a> = Token;
type K2<'a> = RawFd;
iddqd::bi_upcast!();
fn key1(&self) -> Token {
self.token
}
fn key2(&self) -> RawFd {
self.fd
}
}
impl From<TokenFd> for (Token, RawFd) {
fn from(TokenFd { token, fd }: TokenFd) -> (Token, RawFd) {
(token, fd)
}
}
impl From<(Token, RawFd)> for TokenFd {
fn from((token, fd): (Token, RawFd)) -> TokenFd {
TokenFd { token, fd }
}
}

58
src/lib.rs
View file

@ -7,7 +7,7 @@ use std::{
sync::{Arc, LazyLock}, sync::{Arc, LazyLock},
}; };
pub(crate) mod prelude { pub mod prelude {
#![allow(unused_imports)] #![allow(unused_imports)]
pub use std::{ pub use std::{
@ -54,12 +54,9 @@ mod boxext;
mod color; mod color;
pub use color::{_CLI_ENABLE_COLOR, SHOULD_COLOR}; pub use color::{_CLI_ENABLE_COLOR, SHOULD_COLOR};
mod daemon; mod daemon;
pub use daemon::Daemon; //pub use daemon::ApiDoc;
pub use daemon::api as daemon_api; pub use daemon::api as daemon_api;
mod daemon_io; mod daemon_io;
pub use daemon_io::OwnedFdWithFlags;
mod daemon_tokfd;
pub(crate) use daemon_tokfd::TokenFd;
pub mod line; pub mod line;
pub use line::Line; pub use line::Line;
mod nixcmd; mod nixcmd;
@ -117,7 +114,7 @@ pub(crate) fn get_line_to_insert() -> SourceLine {
#[tracing::instrument(level = "debug")] #[tracing::instrument(level = "debug")]
pub fn do_append(args: Arc<Args>, append_args: AppendCmd) -> Result<(), BoxDynError> { pub fn do_append(args: Arc<Args>, append_args: AppendCmd) -> Result<(), BoxDynError> {
let filepath = Path::new(&args.file); let filepath = &args.file;
let filepath: PathBuf = if filepath.is_relative() && !filepath.starts_with("./") { let filepath: PathBuf = if filepath.is_relative() && !filepath.starts_with("./") {
iter::once(OsStr::new("./")) iter::once(OsStr::new("./"))
.chain(filepath.iter()) .chain(filepath.iter())
@ -127,7 +124,7 @@ pub fn do_append(args: Arc<Args>, append_args: AppendCmd) -> Result<(), BoxDynEr
}; };
let source_file = open_source_file(Arc::from(filepath))?; let source_file = open_source_file(Arc::from(filepath))?;
let pri = get_where(source_file.clone())?; let pri = get_where(source_file.clone());
let new_pri = pri - 1; let new_pri = pri - 1;
@ -136,7 +133,7 @@ pub fn do_append(args: Arc<Args>, append_args: AppendCmd) -> Result<(), BoxDynEr
&append_args.name, &append_args.name,
new_pri, new_pri,
&append_args.value, &append_args.value,
)?; );
debug!("new_pri_line={new_pri_line}"); debug!("new_pri_line={new_pri_line}");
@ -147,32 +144,23 @@ pub fn do_append(args: Arc<Args>, append_args: AppendCmd) -> Result<(), BoxDynEr
//#[tracing::instrument(level = "debug")] //#[tracing::instrument(level = "debug")]
pub fn do_daemon(args: Arc<Args>, daemon_args: DaemonCmd) -> Result<(), BoxDynError> { pub fn do_daemon(args: Arc<Args>, daemon_args: DaemonCmd) -> Result<(), BoxDynError> {
let config_file = Path::new(&args.file); let config_file: Arc<Path> = Arc::clone(&args.file);
let config_file: PathBuf = if config_file.is_relative() && !config_file.starts_with("./") {
iter::once(OsStr::new("./"))
.chain(config_file.iter())
.collect()
} else {
config_file.to_path_buf()
};
let config_file: Arc<Path> = Arc::from(config_file);
// FIXME: make configurable? // FIXME: make configurable?
let _ = rustix::process::umask(Mode::from_bits_retain(0o600).complement()); let _ = rustix::process::umask(Mode::from_bits_retain(0o600).complement());
let mut daemon = match daemon_args { let rt = tokio::runtime::Runtime::new().expect("couldn't start tokio runtime");
DaemonCmd { stdin: true, .. } => Daemon::from_stdin(config_file),
DaemonCmd { tcp: Some(tcp), .. } => Daemon::from_tcp_socket_addr(config_file, tcp)?, let config = daemon::Config {
DaemonCmd { socket: None, .. } => Daemon::open_default_socket(config_file)?, config_file: SourceFile::new(config_file).unwrap(),
DaemonCmd { addr: daemon_args.bind,
socket: Some(socket), // FIXME
.. token: None,
} => Daemon::from_unix_socket_path(config_file, &socket)?,
}; };
daemon.enter_loop().unwrap(); rt.block_on(async move {
daemon::run(config).await;
info!("daemon has exited"); });
Ok(()) Ok(())
} }
@ -207,8 +195,8 @@ fn maybe_extract_prio_from_line(line: &SourceLine) -> Option<i64> {
}) })
} }
pub fn get_where(dynamic_nix: SourceFile) -> Result<i64, BoxDynError> { pub fn get_where(dynamic_nix: SourceFile) -> i64 {
let lines = dynamic_nix.lines()?; let lines = dynamic_nix.lines();
let prio = lines let prio = lines
.iter() .iter()
.filter_map(maybe_extract_prio_from_line) .filter_map(maybe_extract_prio_from_line)
@ -216,7 +204,7 @@ pub fn get_where(dynamic_nix: SourceFile) -> Result<i64, BoxDynError> {
.next() // Priorities with lower integer values are "stronger" priorities. .next() // Priorities with lower integer values are "stronger" priorities.
.unwrap_or(0); .unwrap_or(0);
Ok(prio) prio
} }
pub fn get_next_prio_line( pub fn get_next_prio_line(
@ -224,8 +212,8 @@ pub fn get_next_prio_line(
option_name: &str, option_name: &str,
new_prio: i64, new_prio: i64,
new_value: &str, new_value: &str,
) -> Result<SourceLine, BoxDynError> { ) -> SourceLine {
let source_lines = source.lines()?; let source_lines = source.lines();
let penultimate = source_lines.get(source_lines.len() - 2); let penultimate = source_lines.get(source_lines.len() - 2);
// FIXME: don't rely on whitespace lol // FIXME: don't rely on whitespace lol
debug_assert_eq!(penultimate.map(SourceLine::text).as_deref(), Some(" ];")); debug_assert_eq!(penultimate.map(SourceLine::text).as_deref(), Some(" ];"));
@ -243,10 +231,10 @@ pub fn get_next_prio_line(
)), )),
}; };
Ok(new_line) new_line
} }
pub fn write_next_prio(mut source: SourceFile, new_line: SourceLine) -> Result<(), BoxDynError> { pub fn write_next_prio(mut source: SourceFile, new_line: SourceLine) -> Result<(), IoError> {
let new_mod_start = SourceLine { let new_mod_start = SourceLine {
line: new_line.line.prev(), line: new_line.line.prev(),
path: source.path(), path: source.path(),

25
src/line.rs
View file

@ -37,8 +37,33 @@ impl Line {
self.0 self.0
} }
#[cfg(target_pointer_width = "64")]
pub const fn index_usize(self) -> usize {
self.0 as usize
}
/// 1-indexed /// 1-indexed
pub const fn linenr(self) -> u64 { pub const fn linenr(self) -> u64 {
self.0 + 1 self.0 + 1
} }
} }
/// [Alternate](Formatter::alternate) flag capitalizes "line".
///
/// ```
/// # use dynix::Line;
/// let line = Line::from_index(22);
/// assert_eq!(format!("{line}"), "line 23");
/// assert_eq!(format!("{line:#}"), "Line 23");
/// ```
impl Display for Line {
fn fmt(&self, f: &mut Formatter) -> FmtResult {
if f.alternate() {
write!(f, "Line {}", self.linenr())?;
} else {
write!(f, "line {}", self.linenr())?;
}
Ok(())
}
}

5
src/main.rs
View file

@ -11,6 +11,7 @@ use clap::{ColorChoice, Parser as _};
use tracing_human_layer::HumanLayer; use tracing_human_layer::HumanLayer;
use tracing_subscriber::util::SubscriberInitExt; use tracing_subscriber::util::SubscriberInitExt;
use tracing_subscriber::{EnvFilter, layer::SubscriberExt}; use tracing_subscriber::{EnvFilter, layer::SubscriberExt};
use utoipa::OpenApi as _;
fn main_wrapped() -> Result<(), Box<dyn StdError + Send + Sync + 'static>> { fn main_wrapped() -> Result<(), Box<dyn StdError + Send + Sync + 'static>> {
// Default RUST_LOG to warn if it's not specified. // Default RUST_LOG to warn if it's not specified.
@ -43,6 +44,10 @@ fn main_wrapped() -> Result<(), Box<dyn StdError + Send + Sync + 'static>> {
match &args.subcommand { match &args.subcommand {
Append(append_args) => dynix::do_append(args.clone(), append_args.clone())?, Append(append_args) => dynix::do_append(args.clone(), append_args.clone())?,
Daemon(daemon_args) => dynix::do_daemon(args.clone(), daemon_args.clone())?, Daemon(daemon_args) => dynix::do_daemon(args.clone(), daemon_args.clone())?,
OpenApiDocs => {
//let api = dynix::ApiDoc::openapi();
//dbg!(api);
},
}; };
} }

182
src/source.rs
View file

@ -3,12 +3,10 @@
// SPDX-License-Identifier: EUPL-1.1 // SPDX-License-Identifier: EUPL-1.1
use std::{ use std::{
cell::{Ref, RefCell},
hash::Hash, hash::Hash,
io::{BufRead, BufReader, BufWriter}, io::{BufRead, BufReader, BufWriter},
ops::Deref,
ptr, ptr,
sync::{Arc, Mutex, OnceLock}, sync::{Arc, LazyLock},
}; };
use crate::Line; use crate::Line;
@ -18,6 +16,17 @@ use crate::prelude::*;
use fs_err::OpenOptions; use fs_err::OpenOptions;
use itertools::Itertools; use itertools::Itertools;
// parking_lot's RwLock has RwLockReadGuard::map() in stable Rust.
use parking_lot::{MappedRwLockReadGuard, RwLock, RwLockReadGuard};
pub(crate) static DEFAULT_OPEN_OPTIONS: LazyLock<OpenOptions> = LazyLock::new(|| {
let mut opts = fs_err::OpenOptions::new();
opts.read(true)
.write(true)
.create(false)
.custom_flags(libc::O_CLOEXEC);
opts
});
pub fn replace_file<'a>( pub fn replace_file<'a>(
path: &Path, path: &Path,
@ -97,35 +106,17 @@ impl Display for SourceLine {
#[derive(Debug, Clone)] #[derive(Debug, Clone)]
pub struct SourceFile { pub struct SourceFile {
path: Arc<Path>, path: Arc<Path>,
file: Arc<Mutex<File>>, lines: Arc<RwLock<Vec<SourceLine>>>,
/// References to `SourceFile` do not prevent mutating `lines`.
/// Also `lines` is lazily initialized.
lines: Arc<OnceLock<RefCell<Vec<SourceLine>>>>,
}
#[derive(Debug)]
#[repr(transparent)]
pub struct OpaqueDerefSourceLines<'s>(Ref<'s, [SourceLine]>);
impl<'s> Deref for OpaqueDerefSourceLines<'s> {
type Target = [SourceLine];
fn deref(&self) -> &[SourceLine] {
&*self.0
}
}
#[derive(Debug)]
#[repr(transparent)]
pub struct OpaqueDerefSourceLine<'s>(Ref<'s, SourceLine>);
impl<'s> Deref for OpaqueDerefSourceLine<'s> {
type Target = SourceLine;
fn deref(&self) -> &SourceLine {
&*self.0
}
} }
impl SourceFile { impl SourceFile {
pub fn new<P>(path: P) -> Result<Self, IoError>
where
P: Into<Arc<Path>>,
{
Self::open_from(path.into(), DEFAULT_OPEN_OPTIONS.clone())
}
/// Panics if `path` is a directory path instead of a file path. /// Panics if `path` is a directory path instead of a file path.
pub fn open_from(path: Arc<Path>, options: OpenOptions) -> Result<Self, IoError> { pub fn open_from(path: Arc<Path>, options: OpenOptions) -> Result<Self, IoError> {
trace!( trace!(
@ -135,69 +126,43 @@ impl SourceFile {
); );
assert!(path.file_name().is_some()); assert!(path.file_name().is_some());
let file = Arc::new(Mutex::new(options.open(&*path)?)); let mut file = options
.open(&*path)
Ok(Self { .inspect_err(|e| error!("Failed to open path at {}: {e}", path.display()))?;
path, trace!("File opened to {file:?} ({})", file.as_raw_fd());
file, let reader = BufReader::new(&mut file);
lines: Default::default(), let lines = reader
})
}
pub fn buf_reader(&mut self) -> Result<BufReader<&mut File>, IoError> {
let file_mut = Arc::get_mut(&mut self.file)
.unwrap_or_else(|| panic!("'File' for {} has existing handle", self.path.display()))
.get_mut()
.unwrap_or_else(|e| {
panic!("'File' for {} was mutex-poisoned: {e}", self.path.display())
});
let reader = BufReader::new(file_mut);
Ok(reader)
}
fn _lines(&self) -> Result<Ref<'_, [SourceLine]>, IoError> {
if let Some(lines) = self.lines.get() {
let as_slice = Ref::map(lines.borrow(), |lines| lines.as_slice());
return Ok(as_slice);
}
let lines = BufReader::new(&*self.file.lock().unwrap())
.lines() .lines()
.enumerate() .enumerate()
.map(|(index, line_res)| { .map(|(index, line_res)| {
line_res.map(|line| SourceLine { let line = Line::from_index(index as u64);
line: Line::from_index(index as u64), line_res
path: Arc::clone(&self.path), .map(|contents| SourceLine {
text: Arc::from(line), line,
path: Arc::clone(&path),
text: Arc::from(contents),
})
.inspect_err(|e| {
error!("Failed to read line {line} of {}: {e}", path.display());
}) })
}) })
.collect::<Result<Vec<SourceLine>, IoError>>()?; .collect::<Result<Vec<SourceLine>, IoError>>()
// Mutex should have dropped by now. .inspect_err(|e| {
debug_assert!(self.file.try_lock().is_ok()); error!("Failed to read source file at {}: {e}", path.display());
})?;
self.lines.set(RefCell::new(lines)).unwrap(); let lines = Arc::new(RwLock::new(lines));
Ok(self._lines_slice()) Ok(Self { path, lines })
} }
pub fn lines(&self) -> Result<OpaqueDerefSourceLines<'_>, IoError> { pub fn lines(&self) -> _detail::OpaqueSourceLines<'_> {
let lines = self._lines()?; _detail::OpaqueSourceLines(self._lines())
Ok(OpaqueDerefSourceLines(lines))
} }
pub fn line(&self, line: Line) -> Result<OpaqueDerefSourceLine<'_>, IoError> { /// Panics if `line` is out of range.
let lines_lock = self._lines()?; pub fn line(&self, line: Line) -> _detail::OpaqueSourceLine<'_> {
let line = Ref::map(lines_lock, |lines| &lines[line.index() as usize]); _detail::OpaqueSourceLine(self._line(line))
Ok(OpaqueDerefSourceLine(line))
}
/// `lines` but already be initialized.
fn _lines_slice(&self) -> Ref<'_, [SourceLine]> {
debug_assert!(self.lines.get().is_some());
Ref::map(self.lines.get().unwrap().borrow(), |lines| lines.as_slice())
} }
/// With debug assertions, panics if `lines` are not contiguous. /// With debug assertions, panics if `lines` are not contiguous.
@ -210,7 +175,7 @@ impl SourceFile {
debug_assert!(new_lines.is_sorted_by(|lhs, rhs| lhs.line.next() == rhs.line)); debug_assert!(new_lines.is_sorted_by(|lhs, rhs| lhs.line.next() == rhs.line));
let path = self.path(); let path = self.path();
let cur_lines = self.lines()?; let cur_lines = self.lines();
let first_half = cur_lines let first_half = cur_lines
.iter() .iter()
.take(num_lines_before_new) .take(num_lines_before_new)
@ -236,7 +201,9 @@ impl SourceFile {
debug_assert!(final_lines.is_sorted_by(|lhs, rhs| lhs.line.next() == rhs.line)); debug_assert!(final_lines.is_sorted_by(|lhs, rhs| lhs.line.next() == rhs.line));
debug_assert_eq!(cur_lines.len() + new_lines.len(), final_lines.len()); debug_assert_eq!(cur_lines.len() + new_lines.len(), final_lines.len());
// Stop locking self.lines or we won't be able to write to it.
drop(cur_lines); drop(cur_lines);
debug_assert!(!self.lines.is_locked());
let data = final_lines let data = final_lines
.iter() .iter()
@ -244,8 +211,11 @@ impl SourceFile {
.pipe(|iterator| Itertools::intersperse(iterator, b"\n")); .pipe(|iterator| Itertools::intersperse(iterator, b"\n"));
replace_file(&path, data)?; replace_file(&path, data)?;
debug_assert_ne!(self.lines.read().len(), final_lines.len());
// Finally, update state. // Finally, update state.
self.lines.get().unwrap().replace(final_lines); let mut lines_guard = self.lines.write();
*lines_guard = final_lines;
Ok(()) Ok(())
} }
@ -253,6 +223,22 @@ impl SourceFile {
pub fn path(&self) -> Arc<Path> { pub fn path(&self) -> Arc<Path> {
Arc::clone(&self.path) Arc::clone(&self.path)
} }
pub fn display(&self) -> std::path::Display<'_> {
self.path.display()
}
}
impl SourceFile {
fn _lines(&self) -> MappedRwLockReadGuard<'_, [SourceLine]> {
let lines = RwLock::read(&self.lines);
RwLockReadGuard::map(lines, Vec::as_slice)
}
fn _line(&self, line: Line) -> MappedRwLockReadGuard<'_, SourceLine> {
let lines = self._lines();
MappedRwLockReadGuard::map(lines, |lines| lines.get(line.index() as usize).unwrap())
}
} }
impl PartialEq for SourceFile { impl PartialEq for SourceFile {
@ -260,3 +246,33 @@ impl PartialEq for SourceFile {
*self.path == *other.path *self.path == *other.path
} }
} }
/// Types in this module are conceptually opaque, but their concrete implementations
/// are provided because opaque types in Rust are difficult to work with.
pub mod _detail {
use std::ops::Deref;
use super::*;
#[derive(Debug)]
#[repr(transparent)]
pub struct OpaqueSourceLines<'s>(pub(crate) MappedRwLockReadGuard<'s, [SourceLine]>);
impl<'s> Deref for OpaqueSourceLines<'s> {
type Target = [SourceLine];
fn deref(&self) -> &[SourceLine] {
&*self.0
}
}
#[derive(Debug)]
#[repr(transparent)]
pub struct OpaqueSourceLine<'s>(pub(crate) MappedRwLockReadGuard<'s, SourceLine>);
impl<'s> Deref for OpaqueSourceLine<'s> {
type Target = SourceLine;
fn deref(&self) -> &SourceLine {
&*self.0
}
}
}

6
tests/distccd/test-script.py
View file

@ -96,14 +96,12 @@ def dynix_append_cli(option: str, value: Any):
def dynix_append_daemon(option: str, value: Any): def dynix_append_daemon(option: str, value: Any):
import json import json
payload = json.dumps(dict( payload = json.dumps(dict(
action="append",
args=dict(
name=option, name=option,
value=value, value=value,
),
)) ))
status = machine.succeed(f"echo '{payload}' | {testing_client} /run/user/0/dynix.sock") #status = machine.succeed(f"echo '{payload}' | {testing_client} /run/user/0/dynix.sock")
status = machine.succeed(f"echo '{payload}' | curl localhost:42420/set --json @-")
machine.log(f"daemon replied with status {status}") machine.log(f"daemon replied with status {status}")
machine.wait_for_unit("distccd.service") machine.wait_for_unit("distccd.service")

1
tests/dynix-vm-configuration.nix
View file

@ -90,5 +90,6 @@ in
netcat.nc netcat.nc
socat socat
python3 python3
curl
]; ];
} }

7
tests/gotosocial/test-script.py
View file

@ -104,14 +104,11 @@ def dynix_append_cli(option: str, value: Any):
def dynix_append_daemon(option: str, value: Any): def dynix_append_daemon(option: str, value: Any):
import json import json
payload = json.dumps(dict( payload = json.dumps(dict(
action="append",
args=dict(
name=option, name=option,
value=value, value=value,
),
)) ))
status = machine.succeed(f"echo '{payload}' | curl localhost:42420/set --json @-")
machine.succeed(f"echo '{payload}' | {testing_client} /run/user/0/dynix.sock") machine.log(f"daemon replied with status {status}")
@beartype @beartype
def run_all_tests(machine: Machine, *, use_daemon: bool): def run_all_tests(machine: Machine, *, use_daemon: bool):

6
tests/harmonia/test-script.py
View file

@ -69,14 +69,12 @@ def get_config_file() -> dict[str, Any]:
@beartype @beartype
def dynix_append_daemon(option: str, value: Any): def dynix_append_daemon(option: str, value: Any):
payload = json.dumps(dict( payload = json.dumps(dict(
action="append",
args=dict(
name=option, name=option,
value=value, value=value,
),
)) ))
machine.succeed(f"echo '{payload}' | {testing_client} /run/user/0/dynix.sock") status = machine.succeed(f"echo '{payload}' | curl -v localhost:42420/set --json @- 2>&1")
machine.log(f"daemon replied with status {status}")
@beartype @beartype
def dynix_append_cli(option: str, value: Any): def dynix_append_cli(option: str, value: Any):