ALPHA: wire is a tool to deploy nixos systems
wire.althaea.zone/
more work
+122
-26
+2
-2
wire/cli/src/cli.rs
+2
-2
wire/cli/src/cli.rs
···
5
5
use clap::{Args, Parser, Subcommand, ValueEnum};
6
6
use clap_complete::Shell;
7
7
use clap_num::number_range;
8
-
use clap_verbosity_flag::WarnLevel;
8
+
use clap_verbosity_flag::InfoLevel;
9
9
use lib::SubCommandModifiers;
10
10
use lib::hive::Hive;
11
11
use lib::hive::node::{Goal as HiveGoal, Name, SwitchToConfigurationGoal};
···
29
29
pub command: Commands,
30
30
31
31
#[command(flatten)]
32
-
pub verbose: clap_verbosity_flag::Verbosity<WarnLevel>,
32
+
pub verbose: clap_verbosity_flag::Verbosity<InfoLevel>,
33
33
34
34
/// Path or flake reference
35
35
#[arg(long, global = true, default_value = std::env::current_dir().unwrap().into_os_string(), visible_alias("flake"))]
+1
-1
wire/cli/src/main.rs
+1
-1
wire/cli/src/main.rs
+118
-22
wire/cli/src/tracing_setup.rs
+118
-22
wire/cli/src/tracing_setup.rs
···
7
7
sync::TryLockError,
8
8
};
9
9
10
-
use clap_verbosity_flag::{Verbosity, WarnLevel};
10
+
use clap_verbosity_flag::{LogLevel, Verbosity};
11
11
use lib::STDIN_CLOBBER_LOCK;
12
-
use owo_colors::{OwoColorize, Stream};
13
-
use tracing::{Subscriber};
12
+
use owo_colors::{OwoColorize, Stream, Style};
13
+
use tracing::{Level, Subscriber};
14
14
use tracing_log::AsTrace;
15
15
use tracing_subscriber::{
16
-
Layer, field::{RecordFields, VisitFmt}, fmt::{
17
-
FormatEvent, FormatFields, FormattedFields, format::{self, DefaultFields, DefaultVisitor, Format, Full}
18
-
}, layer::SubscriberExt, registry::LookupSpan, util::SubscriberInitExt
16
+
Layer,
17
+
field::{RecordFields, VisitFmt},
18
+
fmt::{
19
+
FormatEvent, FormatFields, FormattedFields,
20
+
format::{self, DefaultFields, DefaultVisitor, Format, Full},
21
+
},
22
+
layer::{Context, SubscriberExt},
23
+
registry::LookupSpan,
24
+
util::SubscriberInitExt,
19
25
};
20
26
21
27
struct NonClobberingWriter {
···
71
77
struct WireEventFormat(Format<Full, ()>);
72
78
struct WireFieldFormat;
73
79
struct WireFieldVisitor<'a>(DefaultVisitor<'a>);
80
+
struct WireLayer;
74
81
75
82
impl<'a> WireFieldVisitor<'a> {
76
83
fn new(writer: format::Writer<'a>, is_empty: bool) -> Self {
···
79
86
}
80
87
81
88
impl<'writer> FormatFields<'writer> for WireFieldFormat {
82
-
fn format_fields<R: RecordFields>(&self, writer: format::Writer<'writer>, fields: R) -> std::fmt::Result {
89
+
fn format_fields<R: RecordFields>(
90
+
&self,
91
+
writer: format::Writer<'writer>,
92
+
fields: R,
93
+
) -> std::fmt::Result {
83
94
let mut v = WireFieldVisitor::new(writer, true);
84
95
fields.record(&mut v);
85
96
// v.finish()
···
90
101
91
102
impl tracing::field::Visit for WireFieldVisitor<'_> {
92
103
fn record_debug(&mut self, field: &tracing::field::Field, value: &dyn std::fmt::Debug) {
93
-
match field.name() {
94
-
"node" => {
95
-
let _ = write!(self.0.writer(), "{:?}", value.if_supports_color(Stream::Stderr, |text| text.bold()));
96
-
},
97
-
_ => return,
104
+
if field.name() == "node" {
105
+
let _ = write!(
106
+
self.0.writer(),
107
+
"{:?}",
108
+
value.if_supports_color(Stream::Stderr, |text| text.bold())
109
+
);
98
110
}
99
111
}
100
112
}
101
113
114
+
fn get_style(level: Level) -> Style {
115
+
let mut style = Style::new();
116
+
117
+
style = match level {
118
+
Level::TRACE => style.purple(),
119
+
Level::DEBUG => style.blue(),
120
+
// info will not change the default
121
+
Level::INFO => style,
122
+
Level::WARN => style.yellow(),
123
+
Level::ERROR => style.red(),
124
+
};
125
+
126
+
style
127
+
}
128
+
129
+
fn fmt_level(level: Level) -> &'static str {
130
+
match level {
131
+
Level::TRACE => "TRACE",
132
+
Level::DEBUG => "DEBUG",
133
+
Level::INFO => " INFO",
134
+
Level::WARN => " WARN",
135
+
Level::ERROR => "ERROR",
136
+
}
137
+
}
138
+
102
139
impl<S, N> FormatEvent<S, N> for WireEventFormat
103
140
where
104
141
S: Subscriber + for<'a> LookupSpan<'a>,
···
128
165
return self.0.format_event(ctx, writer, event);
129
166
}
130
167
131
-
let Some(node_name) = parent.fields().field("node") else {
168
+
if parent.fields().field("node").is_none() {
132
169
return self.0.format_event(ctx, writer, event);
133
-
};
170
+
}
134
171
135
-
let format = WireFieldFormat;
172
+
let style = get_style(*metadata.level());
136
173
137
174
let ext = parent.extensions();
138
-
let fields = &ext
139
-
.get::<FormattedFields<WireFieldFormat>>()
140
-
.expect("will never be `None`");
141
175
142
-
write!(writer, "{fields}")?;
176
+
let node_name = &ext.get::<FormattedFields<WireFieldFormat>>().unwrap();
177
+
178
+
write!(
179
+
writer,
180
+
"{} ",
181
+
fmt_level(*metadata.level()).if_supports_color(Stream::Stderr, |x| {
182
+
if *metadata.level() == Level::INFO {
183
+
x.style(style.green())
184
+
} else {
185
+
x.style(style)
186
+
}
187
+
})
188
+
)?;
189
+
190
+
write!(writer, "{node_name}")?;
191
+
192
+
if let Some(step) = ctx.event_scope().unwrap().from_root().nth(1) {
193
+
write!(writer, " {}", step.name().italic())?;
194
+
}
195
+
196
+
write!(writer, " | ")?;
197
+
198
+
let mut fields = FormattedFields::<DefaultFields>::new(String::new());
199
+
200
+
ctx.format_fields(fields.as_writer(), event)?;
201
+
202
+
write!(writer, "{fields}",)?;
143
203
144
204
writeln!(writer)?;
145
205
···
147
207
}
148
208
}
149
209
150
-
pub fn setup_logging(verbosity: Verbosity<WarnLevel>) {
210
+
impl<S> Layer<S> for WireLayer
211
+
where
212
+
S: Subscriber + for<'a> LookupSpan<'a>,
213
+
{
214
+
fn on_new_span(
215
+
&self,
216
+
attrs: &tracing::span::Attributes<'_>,
217
+
id: &tracing::span::Id,
218
+
ctx: Context<'_, S>,
219
+
) {
220
+
let span = ctx.span(id).unwrap();
221
+
222
+
if span.extensions().get::<WireFieldFormat>().is_some() {
223
+
return;
224
+
}
225
+
226
+
let mut fields = FormattedFields::<WireFieldFormat>::new(String::new());
227
+
if WireFieldFormat
228
+
.format_fields(fields.as_writer(), attrs)
229
+
.is_ok()
230
+
{
231
+
span.extensions_mut().insert(fields);
232
+
}
233
+
}
234
+
}
235
+
236
+
pub fn setup_logging<L: LogLevel>(verbosity: &Verbosity<L>) {
151
237
let filter = verbosity.log_level_filter().as_trace();
152
238
let registry = tracing_subscriber::registry();
153
239
240
+
if verbosity.is_present() {
241
+
let layer = tracing_subscriber::fmt::layer()
242
+
.without_time()
243
+
.with_target(false)
244
+
.with_writer(NonClobberingWriter::new)
245
+
.with_filter(filter);
246
+
247
+
registry.with(layer).init();
248
+
return;
249
+
}
250
+
154
251
let event_formatter = WireEventFormat(format::format().without_time().with_target(false));
155
252
156
253
let layer = tracing_subscriber::fmt::layer()
157
-
.fmt_fields(WireFieldFormat)
158
254
.event_format(event_formatter)
159
255
.with_writer(NonClobberingWriter::new)
160
256
.with_filter(filter);
161
257
162
-
registry.with(layer).init();
258
+
registry.with(layer).with(WireLayer).init();
163
259
}
+1
-1
wire/lib/src/hive/node.rs
+1
-1
wire/lib/src/hive/node.rs
···
388
388
let _ = tx.send(output);
389
389
}
390
390
391
-
#[instrument(skip_all, fields(goal = %self.context.goal, node = %self.context.name))]
391
+
#[instrument(skip_all, fields(node = %self.context.name))]
392
392
pub async fn execute(mut self) -> Result<(), HiveLibError> {
393
393
let (tx, rx) = oneshot::channel();
394
394
self.context.state.evaluation_rx = Some(rx);