git.delta.rocks / jrsonnet / refs/commits / 34f0c725e4c0

--- a/crates/fleet-base/src/deploy.rs
+++ b/crates/fleet-base/src/deploy.rs
@@ -235,17 +235,12 @@
 					error!("failed to disarm rollback run: {e}");
 				}
 			}
-		} else {
-			match host
-				.rm_file("/etc/fleet_rollback_marker", true)
-				.in_current_span()
-				.await
-			{
-				Err(_e) => {
-					// Marker might not exist, yet better try to remove it.
-				}
-				_ => {}
-			}
+		} else if let Err(_e) = host
+			.rm_file("/etc/fleet_rollback_marker", true)
+			.in_current_span()
+			.await
+		{
+			// Marker might not exist, yet better try to remove it.
 		}
 	}
 	Ok(())

--- a/crates/fleet-base/src/host.rs
+++ b/crates/fleet-base/src/host.rs
@@ -214,13 +214,11 @@
 	pub fn set_session_destination(&self, dest: String) {
 		self.session_destination
 			.set(dest)
-			.ok()
 			.expect("session destination is already set")
 	}
 	pub fn set_deploy_kind(&self, kind: DeployKind) {
 		self.deploy_kind
 			.set(kind)
-			.ok()
 			.expect("deploy kind is already set");
 	}
 	pub async fn deploy_kind(&self) -> Result<DeployKind> {
@@ -568,6 +566,7 @@
 			local: true,
 			session: OnceLock::new(),
 			deploy_kind: OnceCell::new(),
+			session_destination: OnceCell::new(),
 		}
 	}
 
@@ -588,6 +587,7 @@
 			local: self.localhost == name,
 			session: OnceLock::new(),
 			deploy_kind: OnceCell::new(),
+			session_destination: OnceCell::new(),
 		})
 	}
 	pub async fn list_hosts(&self) -> Result<Vec<ConfigHost>> {

--- a/crates/fleet-shared/src/encoding.rs
+++ b/crates/fleet-shared/src/encoding.rs
@@ -51,10 +51,10 @@
 		};
 		let data = if let Some(unprefixed) = string.strip_prefix(BASE64_ENCODED_PREFIX) {
 			STANDARD_NO_PAD
-				.decode(unprefixed.replace(|v| matches!(v, '\n' | '\t' | ' '), ""))
+				.decode(unprefixed.replace(['\n', '\t', ' '], ""))
 				.map_err(|e| format!("base64-encoded failed: {e}"))?
 		} else if let Some(unprefixed) = string.strip_prefix(Z85_ENCODED_PREFIX) {
-			z85::decode(unprefixed.replace(|v| matches!(v, '\n' | '\t' | ' '), ""))
+			z85::decode(unprefixed.replace(['\n', '\t', ' '], ""))
 				.map_err(|e| format!("z85-encoded failed: {e}"))?
 		} else if let Some(unprefixed) = string.strip_prefix(PLAINTEXT_NEWLINE_PREFIX) {
 			unprefixed.as_bytes().to_owned()

--- a/crates/nixlike/src/lib.rs
+++ b/crates/nixlike/src/lib.rs
@@ -138,7 +138,7 @@
 					}
 				}
 
-				let key = k.into_iter().last().unwrap();
+				let key = k.into_iter().next_back().unwrap();
 				if map.contains_key(&key) {
 					return Err("can't override object");
 				}

2727
28	type Error = Error;28	type Error = Error;
2929
30	fn serialize_element<T: ?Sized>(&mut self, value: &T) -> Result<(), Self::Error>30	fn serialize_element<T>(&mut self, value: &T) -> Result<(), Self::Error>
31	where31	where
32		T: serde::Serialize,32		T: serde::Serialize,
33		T: ?Sized,
33	{34	{
34		self.0.push(value.serialize(MySerialize)?);35		self.0.push(value.serialize(MySerialize)?);
35		Ok(())36		Ok(())
4445
45	type Error = Error;46	type Error = Error;
4647
47	fn serialize_element<T: ?Sized>(&mut self, value: &T) -> Result<(), Self::Error>48	fn serialize_element<T>(&mut self, value: &T) -> Result<(), Self::Error>
48	where49	where
49		T: serde::Serialize,50		T: serde::Serialize,
51		T: ?Sized,
50	{52	{
51		self.0.push(value.serialize(MySerialize)?);53		self.0.push(value.serialize(MySerialize)?);
52		Ok(())54		Ok(())
6163
62	type Error = Error;64	type Error = Error;
6365
64	fn serialize_field<T: ?Sized>(&mut self, value: &T) -> Result<(), Self::Error>66	fn serialize_field<T>(&mut self, value: &T) -> Result<(), Self::Error>
65	where67	where
66		T: serde::Serialize,68		T: serde::Serialize,
69		T: ?Sized,
67	{70	{
68		self.0.push(value.serialize(MySerialize)?);71		self.0.push(value.serialize(MySerialize)?);
69		Ok(())72		Ok(())
8184
82	type Error = Error;85	type Error = Error;
8386
84	fn serialize_field<T: ?Sized>(&mut self, value: &T) -> Result<(), Self::Error>87	fn serialize_field<T>(&mut self, value: &T) -> Result<(), Self::Error>
85	where88	where
86		T: serde::Serialize,89		T: serde::Serialize,
90		T: ?Sized,
87	{91	{
88		self.1.serialize_field(value)92		self.1.serialize_field(value)
89	}93	}
102106
103	type Error = Error;107	type Error = Error;
104108
105	fn serialize_key<T: ?Sized>(&mut self, key: &T) -> Result<(), Self::Error>109	fn serialize_key<T>(&mut self, key: &T) -> Result<(), Self::Error>
106	where110	where
107		T: serde::Serialize,111		T: serde::Serialize,
112		T: ?Sized,
108	{113	{
109		let _ = self114		let _ = self
110			.1115			.1
111			.insert(key.serialize(MySerialize)?.parse_string()?.to_owned());116			.insert(key.serialize(MySerialize)?.parse_string()?.to_owned());
112		Ok(())117		Ok(())
113	}118	}
114119
115	fn serialize_value<T: ?Sized>(&mut self, value: &T) -> Result<(), Self::Error>120	fn serialize_value<T>(&mut self, value: &T) -> Result<(), Self::Error>
116	where121	where
117		T: serde::Serialize,122		T: serde::Serialize,
123		T: ?Sized,
118	{124	{
119		self.0125		self.0
120			.insert(self.1.take().unwrap(), value.serialize(MySerialize)?);126			.insert(self.1.take().unwrap(), value.serialize(MySerialize)?);
133139
134	type Error = Error;140	type Error = Error;
135141
136	fn serialize_field<T: ?Sized>(&mut self, key: &str, value: &T) -> Result<(), Self::Error>142	fn serialize_field<T>(&mut self, key: &str, value: &T) -> Result<(), Self::Error>
137	where143	where
138		T: serde::Serialize,144		T: serde::Serialize,
145		T: ?Sized,
139	{146	{
140		self.0.insert(key.to_owned(), value.serialize(MySerialize)?);147		self.0.insert(key.to_owned(), value.serialize(MySerialize)?);
141		Ok(())148		Ok(())
153160
154	type Error = Error;161	type Error = Error;
155162
156	fn serialize_field<T: ?Sized>(163	fn serialize_field<T>(&mut self, key: &'static str, value: &T) -> Result<(), Self::Error>
157		&mut self,
158		key: &'static str,
159		value: &T,
160	) -> Result<(), Self::Error>
161	where164	where
162		T: serde::Serialize,165		T: serde::Serialize,
166		T: ?Sized,
163	{167	{
164		self.1.insert(key.to_owned(), value.serialize(MySerialize)?);168		self.1.insert(key.to_owned(), value.serialize(MySerialize)?);
165		Ok(())169		Ok(())
253		Ok(Value::Null)257		Ok(Value::Null)
254	}258	}
255259
256	fn serialize_some<T: ?Sized>(self, value: &T) -> Result<Self::Ok, Self::Error>260	fn serialize_some<T>(self, value: &T) -> Result<Self::Ok, Self::Error>
257	where261	where
258		T: serde::Serialize,262		T: serde::Serialize,
263		T: ?Sized,
259	{264	{
260		value.serialize(self)265		value.serialize(self)
261	}266	}
277		Ok(Value::String(variant.to_string()))282		Ok(Value::String(variant.to_string()))
278	}283	}
279284
280	fn serialize_newtype_struct<T: ?Sized>(285	fn serialize_newtype_struct<T>(
281		self,286		self,
282		_name: &'static str,287		_name: &'static str,
283		value: &T,288		value: &T,
284	) -> Result<Self::Ok, Self::Error>289	) -> Result<Self::Ok, Self::Error>
285	where290	where
286		T: serde::Serialize,291		T: serde::Serialize,
292		T: ?Sized,
287	{293	{
288		value.serialize(self)294		value.serialize(self)
289	}295	}
290296
291	fn serialize_newtype_variant<T: ?Sized>(297	fn serialize_newtype_variant<T>(
292		self,298		self,
293		_name: &'static str,299		_name: &'static str,
294		_variant_index: u32,300		_variant_index: u32,
297	) -> Result<Self::Ok, Self::Error>303	) -> Result<Self::Ok, Self::Error>
298	where304	where
299		T: serde::Serialize,305		T: serde::Serialize,
306		T: ?Sized,
300	{307	{
301		Ok(Value::Object(308		Ok(Value::Object(
302			vec![(variant.to_string(), value.serialize(self)?)]309			vec![(variant.to_string(), value.serialize(self)?)]