Progenitor port

Cargo.toml

@@ -21,11 +21,11 @@ ipnetwork = ">=0"
 trust-dns-resolver = { version = "^0.21.0", features = ["tokio-runtime", "dns-over-openssl"] }
 trust-dns-server = { version = "^0.21.0", features = ["trust-dns-resolver", "dns-over-openssl"] }
 tokio = { version = "1", features = ["full"] }
-zerotier-central-api = { version = "=1.0.3" }
-zerotier-one-api = { version = "=1.0.5" }
 serde = ">=0"
 serde_json = ">=0"
 serde_yaml = ">=0"
+zerotier-central-api = "=1.1.0"
+zerotier-one-api = "=1.1.0"
 toml = ">=0"
 tinytemplate = ">=0"
 rand = ">=0"
@@ -36,6 +36,7 @@ hex = ">=0"
 openssl = ">=0"
 async-trait = ">=0"
 lazy_static = ">=0"
+reqwest = ">=0"
 
 [features]
 vendored-openssl = [ "openssl/vendored" ]

src/addresses.rs

@@ -3,7 +3,7 @@ use std::net::{IpAddr, Ipv6Addr};
 
 use hex::FromHexError;
 use ipnetwork::IpNetwork;
-use zerotier_central_api::models::{Member, Network};
+use zerotier_central_api::types::{Member, Network};
 
 fn digest_hex(code: String) -> Result<u64, FromHexError> {
     Ok(hex::decode(code)?

src/authority.rs

@@ -7,6 +7,13 @@ use std::{
     time::Duration,
 };
 
+use crate::{
+    addresses::Calculator,
+    hosts::{parse_hosts, HostsFile},
+    traits::{ToHostname, ToPointerSOA, ToWildcard},
+    utils::parse_member_name,
+};
+
 use async_trait::async_trait;
 use ipnetwork::IpNetwork;
 use trust_dns_resolver::{
@@ -22,17 +29,6 @@ use trust_dns_server::{
         in_memory::InMemoryAuthority,
     },
 };
-use zerotier_central_api::{
-    apis::configuration::Configuration,
-    models::{Member, Network},
-};
-
-use crate::{
-    addresses::Calculator,
-    hosts::{parse_hosts, HostsFile},
-    traits::{ToHostname, ToPointerSOA, ToWildcard},
-    utils::parse_member_name,
-};
 
 pub async fn find_members(mut zt: ZTAuthority) {
     let mut timer = tokio::time::interval(zt.update_interval);
@@ -101,7 +97,7 @@ pub async fn init_catalog(zt: ZTAuthority) -> Result<Catalog, anyhow::Error> {
 pub struct ZTAuthority {
     pub network_id: String,
     pub hosts_file: Option<PathBuf>,
-    pub config: Configuration,
+    pub client: zerotier_central_api::Client,
     pub reverse_authority_map: HashMap<IpNetwork, RecordAuthority>,
     pub forward_authority: RecordAuthority,
     pub wildcard: bool,
@@ -129,8 +125,8 @@ impl ZTAuthority {
 
     pub async fn configure_members(
         &self,
-        network: Network,
-        members: Vec<Member>,
+        network: zerotier_central_api::types::Network,
+        members: Vec<zerotier_central_api::types::Member>,
     ) -> Result<(), anyhow::Error> {
         let mut forward_records = vec![self.forward_authority.domain_name.clone()];
         let mut reverse_records = HashMap::new();
@@ -151,7 +147,7 @@ impl ZTAuthority {
         let v6assign = network.config.clone().unwrap().v6_assign_mode;
         if v6assign.is_some() {
             let v6assign = v6assign.unwrap().clone();
-            if v6assign.var_6plane.unwrap_or(false) {
+            if v6assign._6plane.unwrap_or(false) {
                 let s = network.clone().sixplane()?;
                 sixplane = Some(s);
             }
@@ -180,9 +176,9 @@ impl ZTAuthority {
                 .await?;
 
             if let Some(ips) = member.clone().config.and_then(|c| {
-                c.ip_assignments.and_then(|ips| {
+                c.ip_assignments.map_or(None, |v| {
                     Some(
-                        ips.iter()
+                        v.iter()
                             .filter_map(|ip| IpAddr::from_str(ip).map_or(None, |ip| Some(ip)))
                             .collect::<Vec<IpAddr>>(),
                     )
@@ -228,21 +224,22 @@ impl ZTAuthority {
         Ok(())
     }
 
-    pub async fn get_members(&self) -> Result<(Network, Vec<Member>), anyhow::Error> {
-        let config = self.config.clone();
+    pub async fn get_members(
+        &self,
+    ) -> Result<
+        (
+            zerotier_central_api::types::Network,
+            Vec<zerotier_central_api::types::Member>,
+        ),
+        anyhow::Error,
+    > {
+        let client = self.client.clone();
         let network_id = self.network_id.clone();
 
-        let members = zerotier_central_api::apis::network_member_api::get_network_member_list(
-            &config,
-            &network_id,
-        )
-        .await?;
-
-        let network =
-            zerotier_central_api::apis::network_api::get_network_by_id(&config, &network_id)
-                .await?;
+        let members = client.get_network_member_list(&network_id).await?;
+        let network = client.get_network_by_id(&network_id).await?;
 
-        Ok((network, members))
+        Ok((network.to_owned(), members.to_owned()))
     }
 }
 
@@ -604,7 +601,7 @@ struct ZTRecord {
 
 impl ZTRecord {
     pub fn new(
-        member: &Member,
+        member: &zerotier_central_api::types::Member,
         sixplane: Option<IpNetwork>,
         rfc4193: Option<IpNetwork>,
         domain_name: Name,
@@ -630,15 +627,16 @@ impl ZTRecord {
             ptr_name = name;
         }
 
-        let mut ips: Vec<IpAddr> = member
+        let mut ips = member
             .clone()
             .config
             .expect("Member config does not exist")
             .ip_assignments
-            .expect("IP assignments for member do not exist")
-            .into_iter()
-            .map(|s| IpAddr::from_str(&s).expect("Could not parse IP address"))
-            .collect();
+            .map_or(Vec::new(), |v| {
+                v.iter()
+                    .map(|s| IpAddr::from_str(s).expect("Could not parse IP address"))
+                    .collect()
+            });
 
         if sixplane.is_some() {
             ips.push(member.clone().sixplane()?.ip());

src/init.rs

@@ -103,7 +103,7 @@ impl Launcher {
 
         let domain_name = domain_or_default(self.domain.as_deref())?;
         let authtoken = authtoken_path(self.secret.as_deref());
-        let config = central_config(central_token(self.token.as_deref())?);
+        let client = central_client(central_token(self.token.as_deref())?)?;
 
         info!("Welcome to ZeroNS!");
         let ips = get_listen_ips(&authtoken, &self.network_id.clone().unwrap()).await?;
@@ -115,7 +115,7 @@ impl Launcher {
                 ips.iter()
                     .map(|i| parse_ip_from_cidr(i.clone()).to_string())
                     .collect(),
-                config.clone(),
+                client.clone(),
                 self.network_id.clone().unwrap(),
             )
             .await?;
@@ -143,14 +143,12 @@ impl Launcher {
 
             let member_name = get_member_name(authtoken, domain_name.clone()).await?;
 
-            let network = zerotier_central_api::apis::network_api::get_network_by_id(
-                &config,
-                &self.network_id.clone().unwrap(),
-            )
-            .await?;
+            let network = client
+                .get_network_by_id(&self.network_id.clone().unwrap())
+                .await?;
 
             if let Some(v6assign) = network.config.clone().unwrap().v6_assign_mode {
-                if v6assign.var_6plane.unwrap_or(false) {
+                if v6assign._6plane.unwrap_or(false) {
                     warn!("6PLANE PTR records are not yet supported");
                 }
 
@@ -169,7 +167,7 @@ impl Launcher {
                 RecordAuthority::new(domain_name.clone().into(), member_name.clone()).await?;
 
             let ztauthority = ZTAuthority {
-                config,
+                client,
                 network_id: self.network_id.clone().unwrap(),
                 hosts: None, // this will be parsed later.
                 hosts_file: self.hosts.clone(),

src/traits.rs

@@ -6,7 +6,7 @@ use lazy_static::lazy_static;
 use regex::Regex;
 use trust_dns_resolver::{proto::error::ProtoError, IntoName, Name};
 use trust_dns_server::client::rr::LowerName;
-use zerotier_central_api::models::Member;
+use zerotier_central_api::types::Member;
 
 pub trait ToPointerSOA {
     fn to_ptr_soa_name(&self) -> Result<LowerName, ProtoError>;
@@ -106,7 +106,7 @@ mod tests {
     use ipnetwork::IpNetwork;
     use trust_dns_resolver::Name;
     use trust_dns_server::client::rr::LowerName;
-    use zerotier_central_api::models::Member;
+    use zerotier_central_api::types::Member;
 
     #[test]
     fn test_to_ptr_soa_name() {
@@ -153,7 +153,22 @@ mod tests {
 
     #[test]
     fn test_to_hostname_member() {
-        let mut member = Member::new();
+        let mut member = Member {
+            supports_rules_engine: None,
+            protocol_version: None,
+            physical_address: None,
+            node_id: None,
+            network_id: None,
+            name: None,
+            last_online: None,
+            id: None,
+            hidden: None,
+            description: None,
+            controller_id: None,
+            config: None,
+            client_version: None,
+            clock: None,
+        };
         member.node_id = Some("foo".to_string());
         let hostname = member.to_hostname().unwrap();
         assert_eq!(hostname, Name::from_str("zt-foo").unwrap());