1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
|
{ depot, pkgs, lib, ... }:
let
imports = {
inherit (depot.users.Profpatsch)
writers;
};
netencode-rs = imports.writers.rustSimpleLib {
name = "netencode";
dependencies = [
depot.third_party.rust-crates.nom
depot.users.Profpatsch.execline.exec-helpers
];
release = false;
verbose = true;
} (builtins.readFile ./netencode.rs);
gen = import ./gen.nix { inherit lib; };
netencode-mustache = imports.writers.rustSimple {
name = "netencode_mustache";
dependencies = [
depot.users.Profpatsch.arglib.netencode.rust
netencode-rs
depot.third_party.rust-crates.mustache
];
} (builtins.readFile ./netencode-mustache.rs);
record-get = imports.writers.rustSimple {
name = "record-get";
dependencies = [
netencode-rs
depot.users.Profpatsch.execline.exec-helpers
depot.users.Profpatsch.arglib.netencode.rust
];
} ''
extern crate netencode;
extern crate arglib_netencode;
extern crate exec_helpers;
use netencode::{encode, dec};
use netencode::dec::{Decoder, DecodeError};
fn main() {
let mut buf = vec![];
let args = exec_helpers::args("record-get", 1);
let field = match std::str::from_utf8(&args[0]) {
Ok(f) => f,
Err(_e) => exec_helpers::die_user_error("record-get", format!("The field name needs to be valid unicode"))
};
let u = netencode::u_from_stdin_or_die_user_error("record-get", &mut buf);
match (dec::RecordDot {field, inner: dec::AnyU }).dec(u) {
Ok(u) => encode(&mut std::io::stdout(), &u).expect("encoding to stdout failed"),
Err(DecodeError(err)) => exec_helpers::die_user_error("record-get", err)
}
}
'';
record-splice-env = imports.writers.rustSimple {
name = "record-splice-env";
dependencies = [
netencode-rs
depot.users.Profpatsch.execline.exec-helpers
];
} ''
extern crate netencode;
extern crate exec_helpers;
use netencode::dec::{Record, Try, ScalarAsBytes, Decoder, DecodeError};
fn main() {
let mut buf = vec![];
let u = netencode::u_from_stdin_or_die_user_error("record-splice-env", &mut buf);
let (_, prog) = exec_helpers::args_for_exec("record-splice-env", 0);
match Record(Try(ScalarAsBytes)).dec(u) {
Ok(map) => {
exec_helpers::exec_into_args(
"record-splice-env",
prog,
// some elements can’t be decoded as scalars, so just ignore them
map.into_iter().filter_map(|(k, v)| v.map(|v2| (k, v2)))
);
},
Err(DecodeError(err)) => exec_helpers::die_user_error("record-splice-env", err),
}
}
'';
env-splice-record = imports.writers.rustSimple {
name = "env-splice-record";
dependencies = [
netencode-rs
depot.users.Profpatsch.execline.exec-helpers
];
} ''
extern crate netencode;
extern crate exec_helpers;
use netencode::{T};
use std::os::unix::ffi::OsStringExt;
fn main() {
exec_helpers::no_args("env-splice-record");
let mut res = std::collections::HashMap::new();
for (key, val) in std::env::vars_os() {
match (String::from_utf8(key.into_vec()), String::from_utf8(val.into_vec())) {
(Ok(k), Ok(v)) => { let _ = res.insert(k, T::Text(v)); },
// same as in record-splice-env, we ignore non-utf8 variables
(_, _) => {},
}
}
netencode::encode(&mut std::io::stdout(), &T::Record(res).to_u()).unwrap()
}
'';
in depot.nix.utils.drvTargets {
inherit
netencode-rs
netencode-mustache
record-get
record-splice-env
env-splice-record
gen
;
}
|
