cloudcheck 8.4.0__tar.gz → 8.4.1__tar.gz

{cloudcheck-8.4.0 → cloudcheck-8.4.1}/Cargo.lock

@@ -56,7 +56,7 @@ checksum = "9330f8b2ff13f34540b44e946ef35111825727b38d33286ef986142615121801"
 
 [[package]]
 name = "cloudcheck"
-version = "8.4.0"
+version = "8.4.1"
 dependencies = [
  "openssl",
  "pyo3",

{cloudcheck-8.4.0 → cloudcheck-8.4.1}/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "cloudcheck"
-version = "8.4.0"
+version = "8.4.1"
 edition = "2024"
 description = "CloudCheck is a simple Rust tool to check whether an IP address or hostname belongs to a cloud provider."
 license = "GPL-3.0"

{cloudcheck-8.4.0 → cloudcheck-8.4.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cloudcheck
-Version: 8.4.0
+Version: 8.4.1
 Summary: Detailed database of cloud providers. Instantly look up a domain or IP address
 Requires-Python: >=3.9
 Description-Content-Type: text/markdown; charset=UTF-8; variant=GFM
@@ -11,11 +11,11 @@ Description-Content-Type: text/markdown; charset=UTF-8; variant=GFM
 [![PyPI](https://img.shields.io/pypi/v/cloudcheck)](https://pypi.org/project/cloudcheck/)
 [![Rust Version](https://img.shields.io/badge/rust-1.70+-orange)](https://www.rust-lang.org)
 [![Crates.io](https://img.shields.io/crates/v/cloudcheck?color=orange)](https://crates.io/crates/cloudcheck)
-[![License](https://img.shields.io/badge/license-GPLv3-blue.svg)](https://github.com/blacklanternsecurity/cloudcheck/blob/master/LICENSE)
+[![License](https://img.shields.io/badge/license-GPLv3-blue.svg)](https://github.com/blacklanternsecurity/cloudcheck/blob/stable/LICENSE)
 [![Ruff](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/ruff/main/assets/badge/v2.json)](https://github.com/astral-sh/ruff)
-[![Rust Tests](https://github.com/blacklanternsecurity/cloudcheck/actions/workflows/rust-tests.yml/badge.svg?branch=master)](https://github.com/blacklanternsecurity/cloudcheck/actions/workflows/rust-tests.yml)
-[![Python Tests](https://github.com/blacklanternsecurity/cloudcheck/actions/workflows/python-tests.yml/badge.svg?branch=master)](https://github.com/blacklanternsecurity/cloudcheck/actions/workflows/python-tests.yml)
-[![Pipeline Tests](https://github.com/blacklanternsecurity/cloudcheck/actions/workflows/pipeline-tests.yml/badge.svg?branch=master)](https://github.com/blacklanternsecurity/cloudcheck/actions/workflows/pipeline-tests.yml)
+[![Rust Tests](https://github.com/blacklanternsecurity/cloudcheck/actions/workflows/rust-tests.yml/badge.svg?branch=stable)](https://github.com/blacklanternsecurity/cloudcheck/actions/workflows/rust-tests.yml)
+[![Python Tests](https://github.com/blacklanternsecurity/cloudcheck/actions/workflows/python-tests.yml/badge.svg?branch=stable)](https://github.com/blacklanternsecurity/cloudcheck/actions/workflows/python-tests.yml)
+[![Pipeline Tests](https://github.com/blacklanternsecurity/cloudcheck/actions/workflows/pipeline-tests.yml/badge.svg?branch=stable)](https://github.com/blacklanternsecurity/cloudcheck/actions/workflows/pipeline-tests.yml)
 
 ### UPDATE: Now rewritten in Rust, with [34 supported cloud providers](#supported-cloud-providers)!
 

{cloudcheck-8.4.0 → cloudcheck-8.4.1}/README.md

@@ -4,11 +4,11 @@
 [![PyPI](https://img.shields.io/pypi/v/cloudcheck)](https://pypi.org/project/cloudcheck/)
 [![Rust Version](https://img.shields.io/badge/rust-1.70+-orange)](https://www.rust-lang.org)
 [![Crates.io](https://img.shields.io/crates/v/cloudcheck?color=orange)](https://crates.io/crates/cloudcheck)
-[![License](https://img.shields.io/badge/license-GPLv3-blue.svg)](https://github.com/blacklanternsecurity/cloudcheck/blob/master/LICENSE)
+[![License](https://img.shields.io/badge/license-GPLv3-blue.svg)](https://github.com/blacklanternsecurity/cloudcheck/blob/stable/LICENSE)
 [![Ruff](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/ruff/main/assets/badge/v2.json)](https://github.com/astral-sh/ruff)
-[![Rust Tests](https://github.com/blacklanternsecurity/cloudcheck/actions/workflows/rust-tests.yml/badge.svg?branch=master)](https://github.com/blacklanternsecurity/cloudcheck/actions/workflows/rust-tests.yml)
-[![Python Tests](https://github.com/blacklanternsecurity/cloudcheck/actions/workflows/python-tests.yml/badge.svg?branch=master)](https://github.com/blacklanternsecurity/cloudcheck/actions/workflows/python-tests.yml)
-[![Pipeline Tests](https://github.com/blacklanternsecurity/cloudcheck/actions/workflows/pipeline-tests.yml/badge.svg?branch=master)](https://github.com/blacklanternsecurity/cloudcheck/actions/workflows/pipeline-tests.yml)
+[![Rust Tests](https://github.com/blacklanternsecurity/cloudcheck/actions/workflows/rust-tests.yml/badge.svg?branch=stable)](https://github.com/blacklanternsecurity/cloudcheck/actions/workflows/rust-tests.yml)
+[![Python Tests](https://github.com/blacklanternsecurity/cloudcheck/actions/workflows/python-tests.yml/badge.svg?branch=stable)](https://github.com/blacklanternsecurity/cloudcheck/actions/workflows/python-tests.yml)
+[![Pipeline Tests](https://github.com/blacklanternsecurity/cloudcheck/actions/workflows/pipeline-tests.yml/badge.svg?branch=stable)](https://github.com/blacklanternsecurity/cloudcheck/actions/workflows/pipeline-tests.yml)
 
 ### UPDATE: Now rewritten in Rust, with [34 supported cloud providers](#supported-cloud-providers)!
 

{cloudcheck-8.4.0 → cloudcheck-8.4.1}/cloudcheck_update/__init__.py

@@ -11,47 +11,6 @@ from cloudcheck.providers.base import BaseProvider
 logging.basicConfig(level=logging.INFO)
 log = logging.getLogger("cloudcheck")
 
-# Dictionary to store loaded provider classes
-_provider_classes: Dict[str, Type[BaseProvider]] = {}
-# Dictionary to store instantiated providers
-providers: Dict[str, BaseProvider] = {}
-
-
-def load_provider_classes() -> Dict[str, Type[BaseProvider]]:
-    """Dynamically load all cloud provider classes from the providers directory."""
-    global _provider_classes
-
-    if _provider_classes:
-        return _provider_classes
-
-    providers_path = Path(__file__).parent.parent / "cloudcheck" / "providers"
-
-    for file in providers_path.glob("*.py"):
-        if file.stem in ("base", "__init__"):
-            continue
-
-        try:
-            import_path = f"cloudcheck.providers.{file.stem}"
-            module = importlib.import_module(import_path)
-
-            # Look for classes that inherit from BaseProvider
-            for attr_name in dir(module):
-                attr = getattr(module, attr_name)
-                if (
-                    isinstance(attr, type)
-                    and issubclass(attr, BaseProvider)
-                    and attr != BaseProvider
-                ):
-                    provider_name = attr.__name__.lower()
-                    _provider_classes[provider_name] = attr
-                    print(f"Loaded provider class: {attr.__name__}")
-
-        except Exception as e:
-            log.error(f"Failed to load provider from {file}: {e}")
-            raise
-
-    return _provider_classes
-
 
 project_root = Path(__file__).parent.parent
 json_path = project_root / "cloud_providers_v2.json"

{cloudcheck-8.4.0 → cloudcheck-8.4.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "maturin"
 
 [project]
 name = "cloudcheck"
-version = "8.4.0"
+version = "8.4.1"
 description = "Detailed database of cloud providers. Instantly look up a domain or IP address"
 readme = "README.md"
 requires-python = ">=3.9"

{cloudcheck-8.4.0 → cloudcheck-8.4.1}/pytest.ini

@@ -3,5 +3,5 @@ testpaths = .
 python_files = test_*.py
 python_classes = Test*
 python_functions = test_*
-norecursedirs = old
-addopts = --ignore=old
+norecursedirs = old target
+addopts = --ignore=old --ignore=target

cloudcheck-8.4.1/src/lib.rs

@@ -0,0 +1,281 @@
+use radixtarget::{RadixTarget, ScopeMode};
+use serde::{Deserialize, Serialize};
+use std::collections::HashMap;
+use std::path::PathBuf;
+use std::sync::Arc;
+use std::time::{Duration, SystemTime};
+use tokio::sync::{Mutex, RwLock};
+
+#[cfg(feature = "py")]
+mod python;
+
+const CLOUDCHECK_SIGNATURE_URL: &str = "https://raw.githubusercontent.com/blacklanternsecurity/cloudcheck/refs/heads/stable/cloud_providers_v2.json";
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct CloudProvider {
+    pub name: String,
+    pub tags: Vec<String>,
+}
+
+#[derive(Debug, Deserialize)]
+struct ProviderData {
+    name: String,
+    tags: Vec<String>,
+    cidrs: Vec<String>,
+    domains: Vec<String>,
+}
+
+type ProvidersMap = HashMap<String, Vec<CloudProvider>>;
+type Error = Box<dyn std::error::Error + Send + Sync>;
+
+#[derive(Clone)]
+pub struct CloudCheck {
+    radix: Arc<RwLock<Option<RadixTarget>>>,
+    providers: Arc<RwLock<Option<ProvidersMap>>>,
+    last_fetch: Arc<Mutex<Option<SystemTime>>>,
+}
+
+impl Default for CloudCheck {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+impl CloudCheck {
+    pub fn new() -> Self {
+        CloudCheck {
+            radix: Arc::new(RwLock::new(None)),
+            providers: Arc::new(RwLock::new(None)),
+            last_fetch: Arc::new(Mutex::new(None)),
+        }
+    }
+
+    fn get_signature_url() -> String {
+        std::env::var("CLOUDCHECK_SIGNATURE_URL")
+            .unwrap_or_else(|_| CLOUDCHECK_SIGNATURE_URL.to_string())
+    }
+
+    fn get_cache_path() -> Result<PathBuf, Error> {
+        let home = std::env::var("HOME")?;
+        let mut path = PathBuf::from(home);
+        path.push(".cache");
+        path.push("cloudcheck");
+        path.push("cloud_providers_v2.json");
+        Ok(path)
+    }
+
+    async fn fetch_and_cache(cache_path: &PathBuf) -> Result<String, Error> {
+        let url = Self::get_signature_url();
+        let response = reqwest::get(&url).await?;
+        let json_data = response.text().await?;
+
+        if let Some(parent) = cache_path.parent() {
+            tokio::fs::create_dir_all(parent).await?;
+        }
+        tokio::fs::write(cache_path, &json_data).await?;
+
+        Ok(json_data)
+    }
+
+    /// Gets the last fetch time, checking in-memory timestamp first.
+    /// If no in-memory timestamp exists (first run), falls back to checking
+    /// the cache file's modification time. Returns None if file doesn't exist.
+    async fn get_last_fetch_time(&self, cache_path: &PathBuf) -> Result<Option<SystemTime>, Error> {
+        let last_fetch = self.last_fetch.lock().await;
+        match *last_fetch {
+            Some(time) => Ok(Some(time)),
+            None => {
+                // No in-memory timestamp - check file modification time
+                drop(last_fetch);
+                match tokio::fs::metadata(cache_path).await {
+                    Ok(metadata) => Ok(metadata.modified().ok()),
+                    Err(_) => Ok(None),
+                }
+            }
+        }
+    }
+
+    /// Loads JSON data either from network (if refresh needed) or from cache file.
+    /// Returns (json_data, fetched_fresh) where fetched_fresh indicates if we
+    /// fetched from network. Sets last_fetch timestamp on first cache load to
+    /// track process runtime. Falls back to network fetch if cache read fails.
+    async fn load_json_data(
+        &self,
+        cache_path: &PathBuf,
+        needs_refresh: bool,
+    ) -> Result<(String, bool), Error> {
+        if needs_refresh {
+            let data = Self::fetch_and_cache(cache_path).await?;
+            Ok((data, true))
+        } else {
+            match tokio::fs::read_to_string(cache_path).await {
+                Ok(data) => {
+                    // First load from cache - set timestamp to track process runtime
+                    let now = SystemTime::now();
+                    let mut last_fetch = self.last_fetch.lock().await;
+                    if last_fetch.is_none() {
+                        *last_fetch = Some(now);
+                    }
+                    Ok((data, false))
+                }
+                Err(_) => {
+                    // Cache file was deleted between stat and read, fetch fresh
+                    let data = Self::fetch_and_cache(cache_path).await?;
+                    Ok((data, true))
+                }
+            }
+        }
+    }
+
+    /// Parses JSON and builds the radix tree and providers map.
+    /// For each provider, inserts all CIDRs and domains into the radix tree,
+    /// normalizing them in the process. Maps normalized values to provider lists.
+    fn build_data_structures(json_data: &str) -> Result<(RadixTarget, ProvidersMap), Error> {
+        let providers_data: HashMap<String, ProviderData> = serde_json::from_str(json_data)?;
+
+        let mut radix = RadixTarget::new(&[], ScopeMode::Normal)?;
+        let mut providers_map: ProvidersMap = HashMap::new();
+
+        for (_, provider) in providers_data {
+            let cloud_provider = CloudProvider {
+                name: provider.name.clone(),
+                tags: provider.tags.clone(),
+            };
+
+            // Insert all CIDRs for this provider
+            for cidr in provider.cidrs {
+                let normalized = match radix.get(&cidr) {
+                    Some(n) => n,
+                    None => match radix.insert(&cidr) {
+                        Ok(Some(n)) => n,
+                        Ok(None) => continue,
+                        Err(e) => {
+                            eprintln!("Error inserting CIDR '{}': {}", cidr, e);
+                            continue;
+                        }
+                    },
+                };
+                providers_map
+                    .entry(normalized.clone())
+                    .or_default()
+                    .push(cloud_provider.clone());
+            }
+
+            // Insert all domains for this provider
+            for domain in provider.domains {
+                let normalized = match radix.get(&domain) {
+                    Some(n) => n,
+                    None => match radix.insert(&domain) {
+                        Ok(Some(n)) => n,
+                        Ok(None) => continue,
+                        Err(e) => {
+                            eprintln!("Error inserting domain '{}': {}", domain, e);
+                            continue;
+                        }
+                    },
+                };
+                providers_map
+                    .entry(normalized.clone())
+                    .or_default()
+                    .push(cloud_provider.clone());
+            }
+        }
+
+        Ok((radix, providers_map))
+    }
+
+    /// Ensures data is loaded and fresh. Checks if refresh is needed based on
+    /// 24-hour process runtime. Returns early if data is already loaded and fresh.
+    /// Otherwise loads data (from network or cache), builds structures, and updates
+    /// the in-memory timestamp if we fetched fresh data.
+    async fn ensure_loaded(&self) -> Result<(), Error> {
+        let cache_valid_duration = Duration::from_secs(24 * 60 * 60);
+        let now = SystemTime::now();
+        let cache_path = Self::get_cache_path()?;
+
+        // Check if we need refresh (uses in-memory timestamp, falls back to file stat)
+        let last_fetch_time = self.get_last_fetch_time(&cache_path).await?;
+        let needs_refresh = match last_fetch_time {
+            Some(fetch_time) => now
+                .duration_since(fetch_time)
+                .map(|elapsed| elapsed >= cache_valid_duration)
+                .unwrap_or(true),
+            None => true,
+        };
+
+        // Early return if data is already loaded and fresh
+        {
+            let radix_guard = self.radix.read().await;
+            if radix_guard.is_some() && !needs_refresh {
+                return Ok(());
+            }
+        }
+
+        // Load JSON data and build structures
+        let (json_data, fetched_fresh) = self.load_json_data(&cache_path, needs_refresh).await?;
+        let (radix, providers_map) = Self::build_data_structures(&json_data)?;
+
+        // Update in-memory data structures
+        {
+            let mut radix_guard = self.radix.write().await;
+            *radix_guard = Some(radix);
+        }
+        {
+            let mut providers_guard = self.providers.write().await;
+            *providers_guard = Some(providers_map);
+        }
+
+        // Update timestamp if we fetched fresh data
+        if fetched_fresh {
+            let mut last_fetch = self.last_fetch.lock().await;
+            *last_fetch = Some(now);
+        }
+
+        Ok(())
+    }
+
+    pub async fn lookup(&self, target: &str) -> Result<Vec<CloudProvider>, Error> {
+        self.ensure_loaded().await?;
+
+        let radix_guard = self.radix.read().await;
+        let providers_guard = self.providers.read().await;
+
+        let radix = radix_guard.as_ref().unwrap();
+        let providers = providers_guard.as_ref().unwrap();
+
+        if let Some(normalized) = radix.get(target) {
+            Ok(providers.get(&normalized).cloned().unwrap_or_default())
+        } else {
+            Ok(Vec::new())
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[tokio::test]
+    async fn test_lookup_google_dns() {
+        let cloudcheck = CloudCheck::new();
+        let results = cloudcheck.lookup("8.8.8.8").await.unwrap();
+        let names: Vec<String> = results.iter().map(|p| p.name.clone()).collect();
+        assert!(
+            names.contains(&"Google".to_string()),
+            "Expected Google in results: {:?}",
+            names
+        );
+    }
+
+    #[tokio::test]
+    async fn test_lookup_amazon_domain() {
+        let cloudcheck = CloudCheck::new();
+        let results = cloudcheck.lookup("asdf.amazon.com").await.unwrap();
+        let names: Vec<String> = results.iter().map(|p| p.name.clone()).collect();
+        assert!(
+            names.contains(&"Amazon".to_string()),
+            "Expected Amazon in results: {:?}",
+            names
+        );
+    }
+}

{cloudcheck-8.4.0 → cloudcheck-8.4.1}/uv.lock

@@ -140,7 +140,7 @@ wheels = [
 
 [[package]]
 name = "cloudcheck"
-version = "8.4.0"
+version = "8.4.1"
 source = { editable = "." }
 
 [package.dev-dependencies]

cloudcheck-8.4.0/src/lib.rs

@@ -1,215 +0,0 @@
-use radixtarget::{RadixTarget, ScopeMode};
-use serde::{Deserialize, Serialize};
-use std::collections::HashMap;
-use std::path::PathBuf;
-use std::sync::Arc;
-use std::time::{Duration, SystemTime};
-use tokio::sync::OnceCell;
-
-#[cfg(feature = "py")]
-mod python;
-
-const CLOUDCHECK_SIGNATURE_URL: &str = "https://raw.githubusercontent.com/blacklanternsecurity/cloudcheck/refs/heads/stable/cloud_providers_v2.json";
-
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct CloudProvider {
-    pub name: String,
-    pub tags: Vec<String>,
-}
-
-#[derive(Debug, Deserialize)]
-struct ProviderData {
-    name: String,
-    tags: Vec<String>,
-    cidrs: Vec<String>,
-    domains: Vec<String>,
-}
-
-#[derive(Clone)]
-pub struct CloudCheck {
-    radix: Arc<OnceCell<RadixTarget>>,
-    providers: Arc<OnceCell<HashMap<String, Vec<CloudProvider>>>>,
-}
-
-impl Default for CloudCheck {
-    fn default() -> Self {
-        Self::new()
-    }
-}
-
-impl CloudCheck {
-    pub fn new() -> Self {
-        CloudCheck {
-            radix: Arc::new(OnceCell::new()),
-            providers: Arc::new(OnceCell::new()),
-        }
-    }
-
-    fn get_signature_url() -> String {
-        std::env::var("CLOUDCHECK_SIGNATURE_URL")
-            .unwrap_or_else(|_| CLOUDCHECK_SIGNATURE_URL.to_string())
-    }
-
-    fn get_cache_path() -> Result<PathBuf, Box<dyn std::error::Error + Send + Sync>> {
-        let home = std::env::var("HOME")?;
-        let mut path = PathBuf::from(home);
-        path.push(".cache");
-        path.push("cloudcheck");
-        path.push("cloud_providers_v2.json");
-        Ok(path)
-    }
-
-    async fn fetch_and_cache(
-        cache_path: &PathBuf,
-    ) -> Result<String, Box<dyn std::error::Error + Send + Sync>> {
-        let url = Self::get_signature_url();
-        let response = reqwest::get(&url).await?;
-        let json_data = response.text().await?;
-
-        if let Some(parent) = cache_path.parent() {
-            tokio::fs::create_dir_all(parent).await?;
-        }
-        tokio::fs::write(cache_path, &json_data).await?;
-
-        Ok(json_data)
-    }
-
-    async fn ensure_loaded(&self) -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
-        let radix_cell = Arc::clone(&self.radix);
-        let providers_cell = Arc::clone(&self.providers);
-
-        radix_cell
-            .get_or_try_init(|| async {
-                let cache_path = Self::get_cache_path()?;
-                let cache_valid_duration = Duration::from_secs(24 * 60 * 60);
-
-                let json_data = match tokio::fs::metadata(&cache_path).await {
-                    Ok(metadata) => {
-                        let modified = metadata.modified()?;
-                        let now = SystemTime::now();
-
-                        if let Ok(elapsed) = now.duration_since(modified) {
-                            if elapsed < cache_valid_duration {
-                                tokio::fs::read_to_string(&cache_path).await?
-                            } else {
-                                Self::fetch_and_cache(&cache_path).await?
-                            }
-                        } else {
-                            Self::fetch_and_cache(&cache_path).await?
-                        }
-                    }
-                    Err(_) => Self::fetch_and_cache(&cache_path).await?,
-                };
-
-                let providers_data: HashMap<String, ProviderData> =
-                    serde_json::from_str(&json_data)?;
-
-                let mut radix = RadixTarget::new(&[], ScopeMode::Normal)?;
-                let mut providers_map: HashMap<String, Vec<CloudProvider>> = HashMap::new();
-
-                for (_, provider) in providers_data {
-                    let cloud_provider = CloudProvider {
-                        name: provider.name.clone(),
-                        tags: provider.tags.clone(),
-                    };
-
-                    for cidr in provider.cidrs {
-                        let normalized = match radix.get(&cidr) {
-                            Some(n) => n,
-                            None => match radix.insert(&cidr) {
-                                Ok(Some(n)) => n,
-                                Ok(None) => continue,
-                                Err(e) => {
-                                    eprintln!("Error inserting CIDR '{}': {}", cidr, e);
-                                    continue;
-                                }
-                            },
-                        };
-                        providers_map
-                            .entry(normalized.clone())
-                            .or_default()
-                            .push(cloud_provider.clone());
-                    }
-
-                    for domain in provider.domains {
-                        // Clean domain: strip comments (everything after #) and trim whitespace
-                        let cleaned_domain = domain.split('#').next().unwrap_or(&domain).trim();
-
-                        if cleaned_domain.is_empty() {
-                            continue;
-                        }
-
-                        let normalized = match radix.get(cleaned_domain) {
-                            Some(n) => n,
-                            None => match radix.insert(cleaned_domain) {
-                                Ok(Some(n)) => n,
-                                Ok(None) => continue,
-                                Err(e) => {
-                                    eprintln!("Error inserting domain '{}': {}", cleaned_domain, e);
-                                    continue;
-                                }
-                            },
-                        };
-                        providers_map
-                            .entry(normalized.clone())
-                            .or_default()
-                            .push(cloud_provider.clone());
-                    }
-                }
-
-                providers_cell
-                    .set(providers_map)
-                    .map_err(|_| "Failed to set providers")?;
-
-                Ok::<RadixTarget, Box<dyn std::error::Error + Send + Sync>>(radix)
-            })
-            .await?;
-
-        Ok(())
-    }
-
-    pub async fn lookup(
-        &self,
-        target: &str,
-    ) -> Result<Vec<CloudProvider>, Box<dyn std::error::Error + Send + Sync>> {
-        self.ensure_loaded().await?;
-
-        let radix = self.radix.get().unwrap();
-        let providers = self.providers.get().unwrap();
-
-        if let Some(normalized) = radix.get(target) {
-            Ok(providers.get(&normalized).cloned().unwrap_or_default())
-        } else {
-            Ok(Vec::new())
-        }
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[tokio::test]
-    async fn test_lookup_google_dns() {
-        let cloudcheck = CloudCheck::new();
-        let results = cloudcheck.lookup("8.8.8.8").await.unwrap();
-        let names: Vec<String> = results.iter().map(|p| p.name.clone()).collect();
-        assert!(
-            names.contains(&"Google".to_string()),
-            "Expected Google in results: {:?}",
-            names
-        );
-    }
-
-    #[tokio::test]
-    async fn test_lookup_amazon_domain() {
-        let cloudcheck = CloudCheck::new();
-        let results = cloudcheck.lookup("asdf.amazon.com").await.unwrap();
-        let names: Vec<String> = results.iter().map(|p| p.name.clone()).collect();
-        assert!(
-            names.contains(&"Amazon".to_string()),
-            "Expected Amazon in results: {:?}",
-            names
-        );
-    }
-}