Cargo.toml

@@ -1,3 +1,6 @@
 [workspace]
-members = ["nzrd", "api", "client"]
+members = [
-resolver = "2"
+    "nzrd",
+    "api",
+    "client",
+]

api/Cargo.toml

@@ -8,9 +8,8 @@ edition = "2021"
 [dependencies]
 figment = { version = "0.10.8", features = ["json", "toml", "env"] }
 serde = { version = "1", features = ["derive"] }
-tarpc = { version = "0.34", features = ["tokio1", "unix"] }
+tarpc = { version = "0.31", features = ["tokio1", "unix"] }
 tokio = { version = "1.0", features = ["macros"] }
 uuid = "1.2.2"
-# trust-dns-proto = { version = "0.23", features = ["serde-config"] }
+trust-dns-proto = { version = "0.22.0", features = ["serde-config"] }
-hickory-proto = { version = "0.24", features = ["serde-config"] }
 log = "0.4.17"

api/src/config.rs

@@ -4,8 +4,8 @@ use figment::{
     providers::{Env, Format, Json, Toml},
     Figment, Metadata, Provider,
 };
-use hickory_proto::rr::Name;
 use serde::{Deserialize, Serialize};
+use trust_dns_proto::rr::Name;
 
 #[derive(Clone, Debug, Serialize, Deserialize)]
 pub struct StorageConfig {

api/src/lib.rs

@@ -5,7 +5,7 @@ pub mod config;
 pub mod model;
 pub mod net;
 
-pub use hickory_proto;
+pub use trust_dns_proto;
 
 #[tarpc::service]
 pub trait Nazrin {

api/src/model.rs

@@ -1,6 +1,6 @@
-use hickory_proto::rr::Name;
 use serde::{Deserialize, Serialize};
 use std::{fmt, net::Ipv4Addr};
+use trust_dns_proto::rr::Name;
 
 use crate::net::{cidr::CidrV4, mac::MacAddr};
 

client/Cargo.toml

@@ -10,14 +10,9 @@ nzr-api = { path = "../api" }
 clap = { version = "4.0.26", features = ["derive"] }
 home = "0.5.4"
 tokio = { version = "1.0", features = ["macros", "rt-multi-thread"] }
-tokio-serde = { version = "0.9", features = ["bincode"] }
+tokio-serde = { version = "0.8.0", features = ["bincode"] }
-tarpc = { version = "0.34", features = [
+tarpc = { version = "0.31", features = ["tokio1", "unix", "serde-transport", "serde-transport-bincode"] }
-    "tokio1",
+tabled = "0.10.0"
-    "unix",
-    "serde-transport",
-    "serde-transport-bincode",
-] }
-tabled = "0.15"
 serde_json = "1"
 log = "0.4.17"
-env_logger = "0.11"
+env_logger = "0.10.0"

client/src/main.rs

@@ -1,7 +1,7 @@
 use clap::{CommandFactory, FromArgMatches, Parser, Subcommand};
-use nzr_api::hickory_proto::rr::Name;
 use nzr_api::model;
 use nzr_api::net::cidr::CidrV4;
+use nzr_api::trust_dns_proto::rr::Name;
 use nzr_api::{config, NazrinClient};
 use std::any::{Any, TypeId};
 use std::path::PathBuf;
@@ -328,8 +328,8 @@ async fn handle_command() -> Result<(), Box<dyn std::error::Error>> {
 
                 let tabular: Vec<table::Instance> =
                     instances?.iter().map(table::Instance::from).collect();
-                let mut table = tabled::Table::new(tabular);
+                let mut table = tabled::Table::new(&tabular);
-                println!("{}", table.with(tabled::settings::Style::psql()));
+                println!("{}", table.with(tabled::Style::psql()));
             }
             InstanceCmd::Prune => (client.garbage_collect(tarpc::context::current()).await?)?,
         },
@@ -423,8 +423,8 @@ async fn handle_command() -> Result<(), Box<dyn std::error::Error>> {
 
                 let tabular: Vec<table::Subnet> =
                     subnets?.iter().map(table::Subnet::from).collect();
-                let mut table = tabled::Table::new(tabular);
+                let mut table = tabled::Table::new(&tabular);
-                println!("{}", table.with(tabled::settings::Style::psql()));
+                println!("{}", table.with(tabled::Style::psql()));
             }
         },
     };

nzrd/Cargo.toml

@@ -6,49 +6,35 @@ edition = "2021"
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
-tarpc = { version = "0.34", features = [
+tarpc = { version = "0.31", features = ["tokio1", "unix", "serde-transport", "serde-transport-bincode"] }
-    "tokio1",
+tokio = { version = "1.0", features = ["macros", "rt-multi-thread", "process"] }
-    "unix",
+tokio-serde = { version = "0.8.0", features = ["bincode"] }
-    "serde-transport",
-    "serde-transport-bincode",
-] }
-tokio = { version = "1", features = ["macros", "rt-multi-thread", "process"] }
-tokio-serde = { version = "0.9", features = ["bincode"] }
 sled = "0.34.7"
-virt = "0.4"
+# virt = "0.2.11"
-# virt = { path = "../../libvirt-rust" }
+virt = { path = "../../libvirt-rust" }
 fatfs = "0.3"
-uuid = { version = "1.2.2", features = [
+uuid = { version = "1.2.2", features = ["v4", "fast-rng", "serde", "macro-diagnostics"] }
-    "v4",
-    "fast-rng",
-    "serde",
-    "macro-diagnostics",
-] }
 clap = { version = "4.0.26", features = ["derive"] }
 serde = { version = "1", features = ["derive"] }
 # for new @attr support, awaiting 0.27.0
-quick-xml = { version = "0.36", features = ["serialize"] }
+quick-xml = { git = "https://github.com/tafia/quick-xml", rev = "fb079b6714d7238d5180aaa098c5f9b02dbcc7da", features = ["serialize"] }
-# quick-xml = { git = "https://github.com/tafia/quick-xml", rev = "fb079b6714d7238d5180aaa098c5f9b02dbcc7da", features = [
+serde_with = "2.1.0"
-#     "serialize",
-# ] }
-serde_with = "2"
 serde_yaml = "0.9.14"
 rand = "0.8.5"
 libc = "0.2.137"
 home = "0.5.4"
 stdext = "0.3.1"
-zerocopy = "0.7"
+zerocopy = "0.6.1"
 nzr-api = { path = "../api" }
 futures = "0.3"
+async-trait = "0.1.60"
 ciborium = "0.2.0"
 ciborium-io = "0.2.0"
-hickory-server = "0.24"
+trust-dns-server = "0.22.0"
-hickory-proto = { version = "0.24", features = ["serde-config"] }
-async-trait = "0.1"
 log = "0.4.17"
-syslog = "7"
+syslog = "6.0.1"
-nix = { version = "0.29", features = ["user", "fs"] }
+nix = "0.26.1"
-tempfile = "3"
+tempdir = "0.3.7"
 
 [dev-dependencies]
 regex = "1"

nzrd/src/cloud.rs

@@ -1,11 +1,11 @@
 use std::net::Ipv4Addr;
 
 use fatfs::FsOptions;
-use hickory_server::proto::rr::Name;
 use serde::Serialize;
 use serde_with::skip_serializing_none;
 use std::collections::HashMap;
 use std::io::{prelude::*, Cursor};
+use trust_dns_server::proto::rr::Name;
 
 use nzr_api::net::{cidr::CidrV4, mac::MacAddr};
 

nzrd/src/cmd/vm.rs

@@ -11,11 +11,11 @@ use crate::ctrl::Storable;
 use crate::ctx::Context;
 use crate::prelude::*;
 use crate::virt::VirtVolume;
-use hickory_server::proto::rr::Name;
 use log::*;
 use nzr_api::args;
 use nzr_api::net::mac::MacAddr;
 use std::sync::Arc;
+use trust_dns_server::proto::rr::Name;
 
 const VIRT_MAC_OUI: &[u8] = &[0x02, 0xf1, 0x0f];
 
@@ -37,10 +37,13 @@ pub async fn new_instance(
     // find the subnet corresponding to the interface
     let subnet = Subnet::get_by_key(ctx.db.clone(), args.subnet.as_bytes())
         .map_err(|er| cmd_error!("Unable to get interface: {}", er))?
-        .ok_or(cmd_error!(
+        .map_or(
-            "Subnet {} wasn't found in database",
+            Err(cmd_error!(
-            &args.subnet
+                "Subnet {} wasn't found in database",
-        ))?;
+                &args.subnet
+            )),
+            Ok,
+        )?;
 
     // bail if a domain already exists
     if let Ok(dom) = virt::domain::Domain::lookup_by_name(&ctx.virt.conn, &args.name) {

nzrd/src/ctrl/virtxml/build.rs

@@ -19,7 +19,7 @@ impl DomainBuilder {
     /// > used to form the filename for storing the persistent
     /// > configuration file.
     pub fn name(mut self, name: &str) -> Self {
-        name.clone_into(&mut self.domain.name);
+        self.domain.name = name.to_owned();
         self
     }
 
@@ -175,7 +175,7 @@ impl IfaceBuilder {
     /// qemu-system-x86_64 -net nic,model=? /dev/null
     /// ```
     pub fn model(mut self, model: &str) -> Self {
-        model.clone_into(&mut self.iface.model.r#type);
+        self.iface.model.r#type = model.to_owned();
         self
     }
 
@@ -233,8 +233,8 @@ impl DiskBuilder {
 
     /// Set the target for the disk to attach to.
     pub fn target(mut self, dev: &str, bus: &str) -> Self {
-        bus.clone_into(&mut self.disk.target.bus);
+        self.disk.target.bus = bus.to_owned();
-        dev.clone_into(&mut self.disk.target.dev);
+        self.disk.target.dev = dev.to_owned();
         self
     }
 

nzrd/src/ctx.rs

@@ -69,7 +69,7 @@ impl std::error::Error for ContextError {}
 impl InnerCtx {
     fn new(config: Config) -> Result<Self, ContextError> {
         let zones = ZoneData::new(&config.dns);
-        let conn = Connect::open(Some(&config.libvirt_uri)).map_err(ContextError::Virt)?;
+        let conn = Connect::open(&config.libvirt_uri).map_err(ContextError::Virt)?;
         virt::error::clear_error_callback();
 
         let pools = PoolRefs {

nzrd/src/dns.rs

@@ -9,12 +9,14 @@ use std::str::FromStr;
 use std::sync::Arc;
 use tokio::sync::{Mutex, RwLock};
 
-use hickory_proto::rr::Name;
+use trust_dns_server::authority::{AuthorityObject, Catalog};
-use hickory_server::authority::{AuthorityObject, Catalog};
+use trust_dns_server::client::rr::{LowerName, RrKey};
-use hickory_server::proto::rr::{rdata::soa, RData, RecordSet};
+use trust_dns_server::proto::rr::{rdata::soa, RData, RecordSet};
-use hickory_server::proto::rr::{LowerName, RrKey};
+use trust_dns_server::server::{Request, RequestHandler, ResponseHandler, ResponseInfo};
-use hickory_server::server::{Request, RequestHandler, ResponseHandler, ResponseInfo};
+use trust_dns_server::{
-use hickory_server::{proto::rr::Record, store::in_memory::InMemoryAuthority};
+    proto::rr::{Name, Record},
+    store::in_memory::InMemoryAuthority,
+};
 
 #[derive(Clone)]
 pub struct CatalogRef(Arc<RwLock<Catalog>>);
@@ -30,14 +32,12 @@ macro_rules! make_serial {
     }};
 }
 
-// hickory_dns 0.24 still requires async_trait
 #[async_trait::async_trait]
 impl RequestHandler for CatalogRef {
-    async fn handle_request<R: ResponseHandler>(
+    async fn handle_request<R>(&self, request: &Request, response_handle: R) -> ResponseInfo
-        &self,
+    where
-        request: &Request,
+        R: ResponseHandler,
-        response_handle: R,
+    {
-    ) -> ResponseInfo {
         self.0
             .read()
             .await
@@ -74,7 +74,7 @@ pub fn make_rectree_with_soa(name: &Name, config: &DNSConfig) -> BTreeMap<RrKey,
     let mut records: BTreeMap<RrKey, RecordSet> = BTreeMap::new();
     let soa_key = RrKey::new(
         LowerName::from(name),
-        hickory_server::proto::rr::RecordType::SOA,
+        trust_dns_server::proto::rr::RecordType::SOA,
     );
     let soa_rec = Record::from_rdata(
         name.clone(),
@@ -100,7 +100,7 @@ impl InnerZD {
             InMemoryAuthority::new(
                 dns_config.default_zone.clone(),
                 records,
-                hickory_server::authority::ZoneType::Primary,
+                trust_dns_server::authority::ZoneType::Primary,
                 false,
             )
             .unwrap()
@@ -123,7 +123,7 @@ impl InnerZD {
             let auth = InMemoryAuthority::new(
                 name.clone(),
                 make_rectree_with_soa(name, &self.config),
-                hickory_server::authority::ZoneType::Primary,
+                trust_dns_server::authority::ZoneType::Primary,
                 false,
             )?;
             self.import(&subnet.ifname.to_string(), auth).await;
@@ -174,7 +174,7 @@ impl InnerZD {
             zone.origin()
         );
 
-        let record = Record::from_rdata(fqdn, 3600, RData::A(addr.into()));
+        let record = Record::from_rdata(fqdn, 3600, RData::A(addr));
         zone.upsert(record, 0).await;
         self.catalog()
             .0
@@ -194,7 +194,7 @@ impl InnerZD {
         if let Some(zone) = zones.get_mut(interface) {
             let hostname: LowerName = hostname.into();
             self.catalog.0.write().await.remove(&hostname);
-            let key = RrKey::new(hostname, hickory_server::proto::rr::RecordType::A);
+            let key = RrKey::new(hostname, trust_dns_server::proto::rr::RecordType::A);
             Ok(zone.records_mut().await.remove(&key).is_some())
         } else {
             Ok(false)

nzrd/src/img.rs

@@ -5,7 +5,7 @@ use std::{
 };
 
 use std::future::Future;
-use tempfile::TempDir;
+use tempdir::TempDir;
 use tokio::process::Command;
 
 use crate::ctrl::virtxml::SizeInfo;
@@ -101,7 +101,7 @@ where
     Fut: Future<Output = std::io::Result<std::process::Output>>,
 {
     let qi_path = qemu_img_path()?;
-    let img_dir = TempDir::with_prefix("nazrin")?;
+    let img_dir = TempDir::new("nazrin")?;
     let img_path = img_dir.path().join("img");
 
     let qi_out = func(Command::new(&qi_path), &img_path)

nzrd/src/main.rs

@@ -11,12 +11,12 @@ mod test;
 mod virt;
 
 use crate::ctrl::{net::Subnet, Storable};
-use hickory_server::ServerFuture;
 use log::LevelFilter;
 use log::*;
 use nzr_api::config;
 use std::str::FromStr;
 use tokio::net::UdpSocket;
+use trust_dns_server::ServerFuture;
 
 #[tokio::main(flavor = "multi_thread")]
 async fn main() -> Result<(), Box<dyn std::error::Error>> {

nzrd/src/rpc.rs

@@ -1,4 +1,3 @@
-use futures::{future, StreamExt};
 use nzr_api::{args, model, Nazrin};
 use std::borrow::Borrow;
 use std::sync::Arc;
@@ -36,6 +35,7 @@ impl NzrServer {
     }
 }
 
+#[tarpc::server]
 impl Nazrin for NzrServer {
     async fn new_instance(
         self,
@@ -55,7 +55,7 @@ impl Nazrin for NzrServer {
 
             {
                 let mut pt = prog_task.write().await;
-                "Starting instance...".clone_into(&mut pt.status_text);
+                pt.status_text = "Starting instance...".to_owned();
                 pt.percentage = 90.0;
             }
             if let Some(addr) = addr {
@@ -281,10 +281,6 @@ pub async fn serve(ctx: Context, zones: ZoneData) -> Result<(), Box<dyn std::err
             let transport = tarpc::serde_transport::new(framed, Bincode::default());
             BaseChannel::with_defaults(transport)
                 .execute(NzrServer::new(ctx, zones).serve())
-                .for_each(|rpc| {
-                    tokio::spawn(rpc);
-                    future::ready(())
-                })
                 .await;
         });
     }

nzrd/src/virt.rs

@@ -75,7 +75,7 @@ impl VirtVolume {
         let svol = StorageVol::create_xml(pool, &xml, flags)?;
 
         if xmldata.vol_type() == Some(VolType::Qcow2) {
-            let size = xmldata.capacity.unwrap();
+            let size = xmldata.capacity.unwrap().clone();
             let src_img = img::create_qcow2(size).await?;
 
             let stream = match Stream::new(&svol.get_connect().map_err(PoolError::VirtError)?, 0) {
@@ -93,7 +93,7 @@ impl VirtVolume {
                 return Err(Box::new(PoolError::CantUpload(er)));
             }
 
-            Self::upload_img(&src_img, stream)?;
+            Self::upload_img(&*src_img, stream)?;
         }
 
         Ok(Self {
@@ -125,7 +125,7 @@ impl VirtVolume {
 
         let src_path = self.get_path().map_err(PoolError::NoPath)?;
 
-        let src_img = img::clone_qcow2(src_path, size)
+        let src_img = img::clone_qcow2(src_path, size.clone())
             .await
             .map_err(PoolError::QemuError)?;
 
@@ -177,7 +177,7 @@ impl VirtVolume {
             return Err(PoolError::CantUpload(er));
         }
 
-        Self::upload_img(&src_img, stream)?;
+        Self::upload_img(&*src_img, stream)?;
 
         Ok(Self {
             inner: cloned,