use std::{collections::HashMap, path::PathBuf, sync::Arc};
use futures::StreamExt;
use hawkbit::ddi::ConfirmationInfo;
use tracing::info;
use crate::{
LOG,
update_source::{
StreamError, StreamSender, Update, UpdateFile, UpdateInfo, UpdateSource, UpdateSourceError,
},
update_workflow::UpdateError,
};
use super::Hawkbit;
#[derive(Debug)]
pub struct HawkbitUpdateInfo {
poll_reply: hawkbit::ddi::Reply,
info: InfoType,
client: hawkbit::ddi::Client,
}
#[derive(Debug)]
pub(crate) enum InfoType {
Confirm(ConfirmationInfo),
Update(Arc<hawkbit::ddi::Update>),
}
#[derive(Debug, Clone)]
pub struct HawkbitUpdate {
pub(crate) update: Arc<hawkbit::ddi::Update>,
}
impl HawkbitUpdateInfo {
pub(crate) async fn try_from_reply(
reply: hawkbit::ddi::Reply,
client: hawkbit::ddi::Client,
) -> Result<Self, UpdateError> {
if let Some(update) = reply.update() {
return Ok(Self {
poll_reply: reply,
info: InfoType::Update(Arc::new(update.fetch().await?)),
client,
});
}
if let Some(confirmation) = reply.confirmation_base() {
return Ok(Self {
poll_reply: reply,
info: InfoType::Confirm(confirmation.update_info().await?),
client,
});
}
Err(UpdateSourceError::InvalidState.into())
}
}
impl UpdateInfo for HawkbitUpdateInfo {
fn needs_consent(&self) -> bool {
matches!(self.info, InfoType::Confirm(_))
}
fn metadata(&self) -> HashMap<String, String> {
match self.info {
InfoType::Update(ref update) => {
let chunks: Vec<hawkbit::ddi::Chunk> = update.chunks().collect();
chunks
.iter()
.flat_map(|c| c.metadata().map(|(k, v)| (k.to_string(), v.to_string())))
.collect()
}
InfoType::Confirm(ref info) => info.metadata().into_iter().collect(),
}
}
fn version(&self) -> String {
match self.info {
InfoType::Update(ref update) => update.action_id().to_string(),
InfoType::Confirm(ref info) => info.action_id().to_string(),
}
}
async fn give_consent(&mut self) -> Result<(), UpdateError> {
match self.info {
InfoType::Update(_) => Ok(()),
InfoType::Confirm(_) => {
self.poll_reply
.confirmation_base()
.unwrap()
.confirm()
.await?;
self.poll_reply = self.client.poll().await?;
self.info = InfoType::Update(Arc::new(
self.poll_reply
.update()
.ok_or(UpdateSourceError::InvalidState)?
.fetch()
.await?,
));
Ok(())
}
}
}
fn update(&self) -> Result<impl Update, UpdateError> {
match &self.info {
InfoType::Update(update) => Ok(HawkbitUpdate {
update: update.clone(),
}),
InfoType::Confirm(_) => Err(UpdateSourceError::ConsentRequired.into()),
}
}
}
impl Update for HawkbitUpdate {
fn as_any(&self) -> &dyn std::any::Any {
self
}
fn version(&self) -> &str {
self.update.action_id()
}
fn size(&self) -> u64 {
let mut size = 0;
for chunk in self.update.chunks() {
for artifact in chunk.artifacts() {
size += artifact.size() as u64;
}
}
size
}
async fn save_to_disk_by_name(
&self,
filename: String,
save_dir: Option<PathBuf>,
) -> Result<UpdateFile<impl Update>, UpdateError> {
for chunk in self.update.chunks() {
let artifact = chunk.artifacts().find(|a| a.filename() == filename);
if let Some(artifact) = artifact {
let save_dir = save_dir.unwrap_or(PathBuf::from(format!(
"/tmp/updated/update_{}",
self.version()
)));
let downloaded_artifact = artifact.download(save_dir.as_path()).await?;
downloaded_artifact.check_sha256().await?;
return UpdateFile::new(downloaded_artifact.file(), self).await;
}
}
Err(UpdateError::UpdateSourceError(
UpdateSourceError::FetchError(format!("Could not find artifact {filename} in update.")),
))
}
async fn stream_by_name(&self, filename: String, tx: &StreamSender) {
for chunk in self.update.chunks() {
let artifact = chunk.artifacts().find(|a| a.filename() == filename);
if let Some(artifact) = artifact {
info!(LOG, "Streaming artifact {}", filename);
match artifact.download_stream_with_sha256_check().await {
Ok(mut stream) => {
while let Some(bytes) = stream.next().await {
if let Err(e) = tx.send(bytes.map_err(StreamError::from)).await {
tx.try_send(Err(e.into())).ok();
}
}
}
Err(e) => {
tx.try_send(Err(e.into())).ok();
}
};
return;
}
}
tx.try_send(Err(StreamError::SendError(format!(
"Could not find artifact {filename} in update."
))))
.ok();
}
fn files(&self) -> Vec<String> {
let mut result = Vec::new();
for chunk in self.update.chunks() {
for artifact in chunk.artifacts() {
result.push(artifact.filename().to_string());
}
}
result
}
}
impl UpdateSource for Hawkbit {
#[allow(refining_impl_trait)]
async fn check_for_updates(&mut self) -> Result<HawkbitUpdateInfo, UpdateError> {
let reply = self.client.poll().await?;
self.polling_interval = reply.polling_sleep()?;
if self.options.handle_config
&& let Some(request) = reply.config_data_request()
{
self.handle_config_request(request).await?;
}
if self.options.handle_cancel
&& let Some(cancel) = reply.cancel_action()
{
self.handle_cancel_action(cancel).await?;
}
if reply.confirmation_base().is_some() || reply.update().is_some() {
return HawkbitUpdateInfo::try_from_reply(reply, self.client.clone()).await;
}
Err(UpdateError::NoPendingUpdates)
}
}