proxmox-mirrors/proxmox-backup-qemu
1
0
Fork 0
mirror of https://git.proxmox.com/git/proxmox-backup-qemu synced 2025-10-04 20:49:26 +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

103
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();
let registry = registry.clone();
let crypt_config = crypt_config.clone();
tokio::spawn(async move {
match client { match client {
Some(client) => { Some(client) => {
handle_async_command( let command_future = add_config(
add_config(
client, client,
crypt_config, crypt_config.clone(),
registry, registry.clone(),
name, name,
data, data,
size, size,
), );
abort_future, tokio::spawn(handle_async_command(command_future, abort.listen(), callback_info));
callback_info,
).await;
} }
None => { None => {
callback_info.send_result(Err(format_err!("not connected"))); 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();
let registry = registry.clone();
let crypt_config = crypt_config.clone();
let known_chunks = known_chunks.clone();
tokio::spawn(async move {
match client { match client {
Some(client) => { Some(client) => {
handle_async_command( let command_future = register_image(
register_image(
client, client,
crypt_config, crypt_config.clone(),
registry, registry.clone(),
known_chunks, known_chunks.clone(),
device_name, device_name,
size, size,
chunk_size, chunk_size,
), );
abort_future, tokio::spawn(handle_async_command(command_future, abort.listen(), callback_info));
callback_info,
).await;
} }
None => { None => {
callback_info.send_result(Err(format_err!("not connected"))); 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();
let registry = registry.clone();
tokio::spawn(async move {
match client { match client {
Some(client) => { Some(client) => {
handle_async_command( let command_future = close_image(client, registry.clone(), dev_id);
close_image(client, registry, dev_id), tokio::spawn(handle_async_command(command_future, abort.listen(), callback_info));
abort_future,
callback_info,
).await;
} }
None => { None => {
callback_info.send_result(Err(format_err!("not connected"))); 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();
let registry = registry.clone();
let crypt_config = crypt_config.clone();
let known_chunks = known_chunks.clone();
let written_bytes2 = written_bytes2.clone();
tokio::spawn(async move {
match client { match client {
Some(client) => { Some(client) => {
written_bytes2.fetch_add(size, Ordering::SeqCst); written_bytes2.fetch_add(size, Ordering::SeqCst);
handle_async_command(
write_data( let command_future = write_data(
client, client,
crypt_config, crypt_config.clone(),
registry, registry.clone(),
known_chunks, known_chunks.clone(),
dev_id, data, dev_id, data,
offset, offset,
size, size,
chunk_size, chunk_size,
), );
abort_future, tokio::spawn(handle_async_command(command_future, abort.listen(), callback_info));
callback_info,
).await;
} }
None => { None => {
callback_info.send_result(Err(format_err!("not connected"))); 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();
let registry = registry.clone();
let crypt_config = crypt_config.clone();
let setup = setup.clone();
tokio::spawn(async move {
match client { match client {
Some(client) => { Some(client) => {
handle_async_command( let command_future = finish_backup(
finish_backup(
client, client,
crypt_config, crypt_config.clone(),
registry, registry.clone(),
setup, setup.clone(),
), );
abort_future, tokio::spawn(handle_async_command(command_future, abort.listen(), callback_info));
callback_info,
).await;
} }
None => { None => {
callback_info.send_result(Err(format_err!("not connected"))); callback_info.send_result(Err(format_err!("not connected")));
} }
} }
});
} }
} }
} }