where R: Read, W: Write
{
let mut bulk_download: Option<Box<dyn Read>> = None;
- let for_response = for_response
+ let mut for_response = for_response
.write_withbulk().context("start to respond")?;
let mut cmd_s = log_enabled!(log::Level::Info)
let upload = bundles.start_upload(ig, kind)?;
(upload, auth)
};
- let uploaded = upload.bulk(&mut bulk_upload, &hash)?;
+ let uploaded = upload.bulk(&mut bulk_upload, &hash, &mut for_response)?;
{
let gref = Instance::lookup_by_name(&game, auth)?;
let mut bundles = gref.lock_bundles();
// There is NO WARRANTY.
use crate::prelude::*;
+use crate::packetframe::ResponseWriter;
//---------- public types ----------
}
#[throws(LE)]
-fn process_bundle(id: Id, instance: &InstanceName) {
+fn process_bundle<W>(id: Id, instance: &InstanceName,
+ _for_progress: &ResponseWriter<W>)
+where W: Write
+{
let dir = id.path_dir(instance);
fs::create_dir(&dir)
.with_context(|| dir.clone()).context("mkdir").map_err(IE::from)?;
impl Uploading {
#[throws(MgmtError)]
- pub fn bulk<R>(self, data: &mut R, expected: &Hash) -> Uploaded
- where R: Read
+ pub fn bulk<R,W>(self, data: &mut R, expected: &Hash,
+ for_progress: &mut ResponseWriter<W>) -> Uploaded
+ where R: Read, W: Write
{
let Uploading { id, mut file, instance } = self;
let tmp = id.path_tmp(&instance);
let parsed = parse_bundle::<LoadError,_>(id, &mut file, &tmp)?;
- process_bundle(id, &*instance)?;
+ process_bundle(id, &*instance, for_progress)?;
Uploaded { id, parsed }
}