git.delta.rocks / jrsonnet / refs/commits / 9fe8d9f6e585

137				bail!("failed to find suitable decrypting host");137				bail!("failed to find suitable decrypting host");
138			}138			}
139			Secret::List {} => {139			Secret::List {} => {
140				/*140				let secrets = config.data.secrets.read().expect("not poisoned");
141				let _span = info_span!("loading secrets").entered();141
142				let configured = config.list_configured_shared()?;142				#[derive(tabled::Tabled)]
143				#[derive(Tabled)]143				struct Row {
144				struct SecretDisplay {144					#[tabled(rename = "Name")]
145					#[tabled(rename = "Name")]145					name: String,
146					name: String,146					#[tabled(rename = "Dist")]
147					#[tabled(rename = "Owners")]147					dist: String,
148					owners: String,148					#[tabled(rename = "Owners")]
149				}149					owners: String,
150				// let mut table = vec![];150				}
151				for name in configured.iter().cloned() {151
152					let config = config.clone();152				let mut rows = Vec::new();
153					let data = config.shared_secret(&name).expect("exists");153				for name in secrets.keys() {
154					/*154					let dists = secrets.get(name).unwrap();
155										let definition = config.shared_secret_definition(&name)?;155					for (idx, dist) in dists.all_distributions().enumerate() {
156										let expectations = definition.expectations()?;156						let active: Vec<_> = dist
157										let owners = data157							.owners()
158											.owners()158							.filter_map(|o| o.as_host())
159											.map(|o| {159							.map(str::to_owned)
160												if expectations.owners.contains(o) {160							.collect();
161													o.green().to_string()161						let pruned: Vec<_> = dist
162												} else {162							.owners_pending_prune()
163													o.red().to_string()163							.filter_map(|o| o.as_host())
164												}
165											})
166											.collect::<Vec<_>>();
167										table.push(SecretDisplay {
168											owners: owners.join(", "),
169											name,
170										})
171					*/
172				}
173				// info!("loaded\n{}", Table::new(table).to_string())
174				*/
175				todo!()164							.map(|h| format!("{h} (pruned)"))
165							.collect();
166						let mut all_owners = active;
167						all_owners.extend(pruned);
168
169						let dist_label = if dist.is_pending_prune() {
170							format!("{idx} (pruned)")
171						} else {
172							idx.to_string()
173						};
174
175						rows.push(Row {
176							name: if idx == 0 {
177								name.clone()
178							} else {
179								String::new()
180							},
181							dist: dist_label,
182							owners: all_owners.join("\n"),
183						});
184					}
185				}
186
187				use tabled::settings::{Style, width::Width};
188				let mut table = tabled::Table::new(rows);
189				table.with(Width::wrap(80));
190				println!("{table}");
176			}191			}
177			Secret::Prune {192			Secret::Prune {
178				name,193				name,

218	pub fn owners(&self) -> impl Iterator<Item = &SecretOwner> {218	pub fn owners(&self) -> impl Iterator<Item = &SecretOwner> {
219		self.owners_ex(false)219		self.owners_ex(false)
220	}220	}
221	pub fn owners_pending_prune(&self) -> impl Iterator<Item = &SecretOwner> {
222		self.owners_pending_prune.keys()
223	}
224	pub fn is_pending_prune(&self) -> bool {
225		self.pending_prune.is_some()
226	}
221227
222	pub fn prune(&mut self, reason: String) {228	pub fn prune(&mut self, reason: String) {
223		assert!(229		assert!(
466		}472		}
467	}473	}
468474
475	pub fn all_distributions(&self) -> impl Iterator<Item = &FleetSecretDistribution> {
476		self.stored.iter()
477	}
469	pub fn distributions(&self) -> impl Iterator<Item = &FleetSecretDistribution> {478	pub fn distributions(&self) -> impl Iterator<Item = &FleetSecretDistribution> {
470		self.stored.iter().filter(|v| v.pending_prune.is_none())479		self.stored.iter().filter(|v| v.pending_prune.is_none())
471	}480	}