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

235					error!("failed to disarm rollback run: {e}");235					error!("failed to disarm rollback run: {e}");
236				}236				}
237			}237			}
238		} else {238		} else if let Err(_e) = host
239			match host
240				.rm_file("/etc/fleet_rollback_marker", true)239			.rm_file("/etc/fleet_rollback_marker", true)
241				.in_current_span()240			.in_current_span()
242				.await241			.await
243			{242		{
244				Err(_e) => {
245					// Marker might not exist, yet better try to remove it.243			// Marker might not exist, yet better try to remove it.
246				}
247				_ => {}
248			}244		}
249		}
250	}245	}
251	Ok(())246	Ok(())
252}247}

214	pub fn set_session_destination(&self, dest: String) {214	pub fn set_session_destination(&self, dest: String) {
215		self.session_destination215		self.session_destination
216			.set(dest)216			.set(dest)
217			.ok()
218			.expect("session destination is already set")217			.expect("session destination is already set")
219	}218	}
220	pub fn set_deploy_kind(&self, kind: DeployKind) {219	pub fn set_deploy_kind(&self, kind: DeployKind) {
221		self.deploy_kind220		self.deploy_kind
222			.set(kind)221			.set(kind)
223			.ok()
224			.expect("deploy kind is already set");222			.expect("deploy kind is already set");
225	}223	}
226	pub async fn deploy_kind(&self) -> Result<DeployKind> {224	pub async fn deploy_kind(&self) -> Result<DeployKind> {
568			local: true,566			local: true,
569			session: OnceLock::new(),567			session: OnceLock::new(),
570			deploy_kind: OnceCell::new(),568			deploy_kind: OnceCell::new(),
569			session_destination: OnceCell::new(),
571		}570		}
572	}571	}
573572
588			local: self.localhost == name,587			local: self.localhost == name,
589			session: OnceLock::new(),588			session: OnceLock::new(),
590			deploy_kind: OnceCell::new(),589			deploy_kind: OnceCell::new(),
590			session_destination: OnceCell::new(),
591		})591		})
592	}592	}
593	pub async fn list_hosts(&self) -> Result<Vec<ConfigHost>> {593	pub async fn list_hosts(&self) -> Result<Vec<ConfigHost>> {

51		};51		};
52		let data = if let Some(unprefixed) = string.strip_prefix(BASE64_ENCODED_PREFIX) {52		let data = if let Some(unprefixed) = string.strip_prefix(BASE64_ENCODED_PREFIX) {
53			STANDARD_NO_PAD53			STANDARD_NO_PAD
54				.decode(unprefixed.replace(|v| matches!(v, '\n' | '\t' | ' '), ""))54				.decode(unprefixed.replace(['\n', '\t', ' '], ""))
55				.map_err(|e| format!("base64-encoded failed: {e}"))?55				.map_err(|e| format!("base64-encoded failed: {e}"))?
56		} else if let Some(unprefixed) = string.strip_prefix(Z85_ENCODED_PREFIX) {56		} else if let Some(unprefixed) = string.strip_prefix(Z85_ENCODED_PREFIX) {
57			z85::decode(unprefixed.replace(|v| matches!(v, '\n' | '\t' | ' '), ""))57			z85::decode(unprefixed.replace(['\n', '\t', ' '], ""))
58				.map_err(|e| format!("z85-encoded failed: {e}"))?58				.map_err(|e| format!("z85-encoded failed: {e}"))?
59		} else if let Some(unprefixed) = string.strip_prefix(PLAINTEXT_NEWLINE_PREFIX) {59		} else if let Some(unprefixed) = string.strip_prefix(PLAINTEXT_NEWLINE_PREFIX) {
60			unprefixed.as_bytes().to_owned()60			unprefixed.as_bytes().to_owned()

138					}138					}
139				}139				}
140140
141				let key = k.into_iter().last().unwrap();141				let key = k.into_iter().next_back().unwrap();
142				if map.contains_key(&key) {142				if map.contains_key(&key) {
143					return Err("can't override object");143					return Err("can't override object");
144				}144				}

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)?)]