proxmox-mirrors/proxmox-backup-qemu
1
0
Fork 0
mirror of https://git.proxmox.com/git/proxmox-backup-qemu synced 2025-10-04 19:04:24 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

simplify rust code

Browse Source
This commit is contained in:
Dietmar Maurer 2019-10-25 12:25:46 +02:00
parent ca246b4590
commit aa47e26411
1 changed files with 81 additions and 124 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

205
src/worker_task.rs
View File

@ -142,16 +142,15 @@ fn backup_worker_task(
BackupMessage::Connect { callback_info } => { BackupMessage::Connect { callback_info } => {
let client = client.clone(); let client = client.clone();
let setup = setup.clone(); let setup = setup.clone();
let abort_future = abort.listen();
tokio::spawn(async move { let command_future = async move {
let command = async move { let writer = setup.connect().await?;
let writer = setup.connect().await?; let mut guard = client.lock().unwrap();
let mut guard = client.lock().unwrap(); *guard = Some(writer);
*guard = Some(writer); Ok(0)
Ok(0) };
};
handle_async_command(command, abort_future, callback_info).await; tokio::spawn(handle_async_command(command_future, abort.listen(), callback_info));
});
} }
BackupMessage::Abort => { BackupMessage::Abort => {
println!("worker got abort mesage"); println!("worker got abort mesage");
@ -166,136 +165,94 @@ fn backup_worker_task(
} }
BackupMessage::AddConfig { name, data, size, callback_info } => { BackupMessage::AddConfig { name, data, size, callback_info } => {
let client = (*(client.lock().unwrap())).clone(); let client = (*(client.lock().unwrap())).clone();
let abort_future = abort.listen(); match client {
let registry = registry.clone(); Some(client) => {
let crypt_config = crypt_config.clone(); let command_future = add_config(
tokio::spawn(async move { client,
match client { crypt_config.clone(),
Some(client) => { registry.clone(),
handle_async_command( name,
add_config( data,
client, size,
crypt_config, );
registry, tokio::spawn(handle_async_command(command_future, abort.listen(), callback_info));
name,
data,
size,
),
abort_future,
callback_info,
).await;
}
None => {
callback_info.send_result(Err(format_err!("not connected")));
}
} }
}); None => {
callback_info.send_result(Err(format_err!("not connected")));
}
}
} }
BackupMessage::RegisterImage { device_name, size, callback_info} => { BackupMessage::RegisterImage { device_name, size, callback_info} => {
let client = (*(client.lock().unwrap())).clone(); let client = (*(client.lock().unwrap())).clone();
let abort_future = abort.listen(); match client {
let registry = registry.clone(); Some(client) => {
let crypt_config = crypt_config.clone(); let command_future = register_image(
let known_chunks = known_chunks.clone(); client,
tokio::spawn(async move { crypt_config.clone(),
match client { registry.clone(),
Some(client) => { known_chunks.clone(),
handle_async_command( device_name,
register_image( size,
client, chunk_size,
crypt_config, );
registry, tokio::spawn(handle_async_command(command_future, abort.listen(), callback_info));
known_chunks,
device_name,
size,
chunk_size,
),
abort_future,
callback_info,
).await;
}
None => {
callback_info.send_result(Err(format_err!("not connected")));
}
} }
}); None => {
callback_info.send_result(Err(format_err!("not connected")));
}
}
} }
BackupMessage::CloseImage { dev_id, callback_info } => { BackupMessage::CloseImage { dev_id, callback_info } => {
let client = (*(client.lock().unwrap())).clone(); let client = (*(client.lock().unwrap())).clone();
let abort_future = abort.listen(); match client {
let registry = registry.clone(); Some(client) => {
tokio::spawn(async move { let command_future = close_image(client, registry.clone(), dev_id);
match client { tokio::spawn(handle_async_command(command_future, abort.listen(), callback_info));
Some(client) => { }
handle_async_command( None => {
close_image(client, registry, dev_id), callback_info.send_result(Err(format_err!("not connected")));
abort_future, }
callback_info, }
).await;
}
None => {
callback_info.send_result(Err(format_err!("not connected")));
}
}
});
} }
BackupMessage::WriteData { dev_id, data, offset, size, callback_info } => { BackupMessage::WriteData { dev_id, data, offset, size, callback_info } => {
let client = (*(client.lock().unwrap())).clone(); let client = (*(client.lock().unwrap())).clone();
let abort_future = abort.listen(); match client {
let registry = registry.clone(); Some(client) => {
let crypt_config = crypt_config.clone(); written_bytes2.fetch_add(size, Ordering::SeqCst);
let known_chunks = known_chunks.clone();
let written_bytes2 = written_bytes2.clone(); let command_future = write_data(
tokio::spawn(async move { client,
match client { crypt_config.clone(),
Some(client) => { registry.clone(),
written_bytes2.fetch_add(size, Ordering::SeqCst); known_chunks.clone(),
handle_async_command( dev_id, data,
write_data( offset,
client, size,
crypt_config, chunk_size,
registry, );
known_chunks, tokio::spawn(handle_async_command(command_future, abort.listen(), callback_info));
dev_id, data,
offset,
size,
chunk_size,
),
abort_future,
callback_info,
).await;
}
None => {
callback_info.send_result(Err(format_err!("not connected")));
}
} }
}); None => {
callback_info.send_result(Err(format_err!("not connected")));
}
}
} }
BackupMessage::Finish { callback_info } => { BackupMessage::Finish { callback_info } => {
let client = (*(client.lock().unwrap())).clone(); let client = (*(client.lock().unwrap())).clone();
let abort_future = abort.listen(); match client {
let registry = registry.clone(); Some(client) => {
let crypt_config = crypt_config.clone(); let command_future = finish_backup(
let setup = setup.clone(); client,
tokio::spawn(async move { crypt_config.clone(),
match client { registry.clone(),
Some(client) => { setup.clone(),
handle_async_command( );
finish_backup( tokio::spawn(handle_async_command(command_future, abort.listen(), callback_info));
client,
crypt_config,
registry,
setup,
),
abort_future,
callback_info,
).await;
}
None => {
callback_info.send_result(Err(format_err!("not connected")));
}
} }
}); None => {
callback_info.send_result(Err(format_err!("not connected")));
}
}
} }
} }
} }