bunny2fmc 1.0.8__py3-none-any.whl

bunny2fmc/__init__.py

@@ -0,0 +1,6 @@
+"""
+bunny2fmc: Sync BunnyCDN edge IPs to Cisco FMC Dynamic Objects
+"""
+
+__version__ = "1.0.8"
+__author__ = "Kasper Elsborg -Wingmen"

bunny2fmc/cli.py

@@ -0,0 +1,288 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+
+"""
+bunny2fmc CLI: Main entry point with argparse, credential management, and logging
+"""
+
+import argparse
+import logging
+import sys
+from logging.handlers import RotatingFileHandler
+
+import bunny2fmc
+from bunny2fmc.config import CredentialManager, ConfigManager
+from bunny2fmc.sync_engine import sync
+
+
+# Global epilog text for help output
+_EPILOG = """
+Examples:
+  bunny2fmc --setup             # First time setup with interactive prompts
+  bunny2fmc                     # Run sync (default if no arguments)
+  bunny2fmc --run               # Explicit run command
+  bunny2fmc --show-config       # View current settings
+  bunny2fmc --clear-config      # Reset all credentials and configuration
+
+Interactive Setup Prompts:
+  • FMC IP Address (e.g., 192.168.3.122) - automatically prepends https://
+  • FMC Username (account with API access)
+  • FMC Password (stored securely in OS Keyring)
+  • Dynamic Object Name (create or select in FMC)
+  • Include IPv6? (yes/no - include IPv6 endpoint ranges)
+  • Sync Interval (minutes - for cron job scheduling)
+
+Cron Scheduling Examples (after setup):
+  */5 * * * *    bunny2fmc      # Every 5 minutes
+  */15 * * * *   bunny2fmc      # Every 15 minutes
+  0 3 * * *      bunny2fmc      # Daily at 3 AM
+
+Documentation & Support:
+  GitHub:  https://github.com/IronKeyVault/Bunny_Sync_FMC
+  PyPI:    https://pypi.org/project/bunny2fmc/
+  Logs:    ~/.local/share/bunny2fmc/logs/bunny2fmc.log
+  Config:  ~/.local/share/bunny2fmc/config.json
+
+Credentials Security:
+  All credentials stored securely in OS Keyring (never plain text):
+  • Linux:   Secret Service (D-Bus)
+  • macOS:   Keychain
+  • Windows: Credential Manager
+"""
+
+
+def setup_logging(log_file):
+    """Configure logging with file rotation (10 MB per file, max 5 backups)"""
+    log_format = "%(asctime)s  %(levelname)s  %(name)s  %(message)s"
+    
+    logger = logging.getLogger("bunny2fmc")
+    logger.setLevel(logging.INFO)
+
+    file_handler = RotatingFileHandler(
+        log_file,
+        maxBytes=10 * 1024 * 1024,
+        backupCount=5,
+    )
+    file_handler.setLevel(logging.INFO)
+    file_handler.setFormatter(logging.Formatter(log_format))
+    logger.addHandler(file_handler)
+
+    console_handler = logging.StreamHandler()
+    console_handler.setLevel(logging.INFO)
+    console_handler.setFormatter(logging.Formatter(log_format))
+    logger.addHandler(console_handler)
+
+    return logger
+
+
+def interactive_setup():
+    """Interactive setup: prompt for credentials and interval."""
+    print("\n" + "=" * 60)
+    print("bunny2fmc - Initial Configuration")
+    print("=" * 60)
+    print("Enter your FMC and Bunny configuration.\n")
+
+    while True:
+        fmc_ip = input("Enter FMC IP Address (e.g., 192.168.3.122): ").strip()
+        if fmc_ip:
+            fmc_base_url = f"https://{fmc_ip}"
+            break
+        print("FMC IP Address cannot be empty.")
+
+    while True:
+        fmc_username = input("Enter FMC Username: ").strip()
+        if fmc_username:
+            break
+        print("FMC Username cannot be empty.")
+
+    while True:
+        fmc_password = input("Enter FMC Password: ").strip()
+        if fmc_password:
+            break
+        print("FMC Password cannot be empty.")
+
+    while True:
+        fmc_dynamic_name = input("Enter Dynamic Object Name (e.g., BunnyCDN_Dynamic): ").strip()
+        if fmc_dynamic_name:
+            break
+        print("Dynamic Object Name cannot be empty.")
+
+    include_ipv6_str = input("Include IPv6 endpoints? (y/n, default: n): ").strip().lower()
+    include_ipv6 = include_ipv6_str in ("y", "yes", "1", "true")
+
+    while True:
+        interval_str = input("Sync interval in minutes (e.g., 15): ").strip()
+        try:
+            sync_interval_minutes = int(interval_str)
+            if sync_interval_minutes > 0:
+                break
+            print("Interval must be a positive number.")
+        except ValueError:
+            print("Interval must be a valid integer.")
+
+    print("\n" + "-" * 60)
+    print("Configuration Summary:")
+    print(f"  FMC URL:              {fmc_base_url}")
+    print(f"  FMC Username:         {fmc_username}")
+    print(f"  Dynamic Object Name:  {fmc_dynamic_name}")
+    print(f"  Include IPv6:         {include_ipv6}")
+    print(f"  Sync Interval:        {sync_interval_minutes} minute(s)")
+    print("-" * 60)
+
+    confirm = input("\nSave this configuration? (y/n): ").strip().lower()
+    if confirm not in ("y", "yes"):
+        print("Setup cancelled.")
+        return None
+
+    return {
+        "fmc_base_url": fmc_base_url,
+        "fmc_username": fmc_username,
+        "fmc_password": fmc_password,
+        "fmc_dynamic_name": fmc_dynamic_name,
+        "include_ipv6": include_ipv6,
+        "sync_interval_minutes": sync_interval_minutes,
+    }
+
+
+def cmd_setup(args):
+    """Handle --setup flag"""
+    config = interactive_setup()
+    if not config:
+        sys.exit(1)
+
+    try:
+        CredentialManager.set_credentials(
+            config["fmc_base_url"],
+            config["fmc_username"],
+            config["fmc_password"],
+            config["sync_interval_minutes"],
+        )
+        ConfigManager.save_dynamic_object_name(config["fmc_dynamic_name"])
+        ConfigManager.save_include_ipv6(config["include_ipv6"])
+
+        print("\n✓ Configuration saved securely!")
+        print(f"\nYou can now run: bunny2fmc")
+        print(f"\nTo run the sync immediately:")
+        print(f"  bunny2fmc --run")
+        print(f"\nTo schedule with cron (for {config['sync_interval_minutes']} minute interval):")
+        print(f"  */{config['sync_interval_minutes']} * * * * bunny2fmc --run")
+        sys.exit(0)
+    except Exception as e:
+        print(f"\n✗ Failed to save configuration: {e}")
+        sys.exit(1)
+
+
+def cmd_run(args, logger):
+    """Handle --run flag or normal execution"""
+    creds = CredentialManager.get_credentials()
+    if not creds:
+        logger.error("No stored credentials found. Run: bunny2fmc --setup")
+        print("Error: No stored credentials found.\nPlease run: bunny2fmc --setup")
+        sys.exit(1)
+
+    fmc_dynamic_name = ConfigManager.load_dynamic_object_name()
+    if not fmc_dynamic_name:
+        logger.error("No Dynamic Object name configured. Run: bunny2fmc --setup")
+        print("Error: No Dynamic Object name configured.\nPlease run: bunny2fmc --setup")
+        sys.exit(1)
+
+    include_ipv6 = ConfigManager.load_include_ipv6()
+
+    logger.info("Starting bunny2fmc sync")
+    logger.info("Dynamic Object: %s", fmc_dynamic_name)
+
+    result = sync(
+        fmc_base_url=creds["fmc_base_url"],
+        fmc_username=creds["fmc_username"],
+        fmc_password=creds["fmc_password"],
+        dynamic_object_name=fmc_dynamic_name,
+        include_ipv6=include_ipv6,
+        verify_ssl=True,
+        dry_run=False,
+        chunk_size=500,
+    )
+
+    if result["status"] == "success":
+        logger.info("Sync completed: +%d -%d (total: %d)", result["added"], result["removed"], result["total_desired"])
+        print(f"\n✓ Sync completed successfully!\n  Added:   {result['added']}\n  Removed: {result['removed']}\n  Total:   {result['total_desired']}")
+        sys.exit(0)
+    else:
+        logger.error("Sync failed: %s", result["message"])
+        print(f"\n✗ Sync failed: {result['message']}")
+        sys.exit(1)
+
+
+def cmd_show_config(args, logger):
+    """Handle --show-config flag"""
+    creds = CredentialManager.get_credentials()
+    if not creds:
+        print("No configuration found. Run: bunny2fmc --setup")
+        return
+
+    fmc_dynamic_name = ConfigManager.load_dynamic_object_name()
+    include_ipv6 = ConfigManager.load_include_ipv6()
+
+    print("\n" + "=" * 60)
+    print("Current Configuration:")
+    print("=" * 60)
+    print(f"FMC Base URL:        {creds['fmc_base_url']}")
+    print(f"FMC Username:        {creds['fmc_username']}")
+    print(f"Dynamic Object Name: {fmc_dynamic_name}")
+    print(f"Include IPv6:        {include_ipv6}")
+    print(f"Sync Interval:       {creds['sync_interval_minutes']} minute(s)")
+    print("=" * 60 + "\n")
+
+
+def cmd_clear_config(args, logger):
+    """Handle --clear-config flag"""
+    confirm = input("Are you sure you want to clear all stored configuration? (y/n): ").strip().lower()
+    if confirm not in ("y", "yes"):
+        print("Cancelled.")
+        return
+
+    try:
+        CredentialManager.clear_credentials()
+        print("✓ Configuration cleared.")
+    except Exception as e:
+        logger.error("Failed to clear configuration: %s", e)
+        print(f"✗ Failed to clear configuration: {e}")
+
+
+def main():
+    """Main entry point with comprehensive help"""
+    parser = argparse.ArgumentParser(
+        prog="bunny2fmc",
+        description="Sync BunnyCDN edge IPs to Cisco FMC Dynamic Objects with secure credential management",
+        epilog=_EPILOG,
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+    )
+
+    parser.add_argument("--version", action="version", version=f"%(prog)s {bunny2fmc.__version__}")
+    parser.add_argument("--setup", action="store_true", help="Interactive setup: Configure FMC credentials, Dynamic Object name, IPv6 option, and sync interval")
+    parser.add_argument("--run", action="store_true", help="Execute sync immediately using stored credentials")
+    parser.add_argument("--show-config", action="store_true", help="Display current configuration (FMC, Dynamic Object name, interval, etc.)")
+    parser.add_argument("--clear-config", action="store_true", help="Clear all credentials and configuration")
+
+    args = parser.parse_args()
+
+    ConfigManager.ensure_directories()
+    log_file = ConfigManager.get_log_file()
+    logger = setup_logging(log_file)
+
+    logger.info("bunny2fmc started with args: %s", sys.argv[1:])
+
+    if args.setup:
+        cmd_setup(args)
+    elif args.show_config:
+        cmd_show_config(args, logger)
+    elif args.clear_config:
+        cmd_clear_config(args, logger)
+    elif args.run or len(sys.argv) == 1:
+        cmd_run(args, logger)
+    else:
+        parser.print_help()
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()

bunny2fmc/config.py

@@ -0,0 +1,128 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""Secure credential and configuration management using OS keyring"""
+import json, os, logging, keyring
+from pathlib import Path
+
+log = logging.getLogger("bunny2fmc")
+SERVICE_NAME = "bunny2fmc"
+CONFIG_DIR = Path.home() / ".local" / "share" / "bunny2fmc"
+CONFIG_FILE = CONFIG_DIR / "config.json"
+LOG_DIR = CONFIG_DIR / "logs"
+
+class CredentialManager:
+    @staticmethod
+    def set_credentials(fmc_base_url: str, fmc_username: str, fmc_password: str, sync_interval_minutes: int):
+        try:
+            keyring.set_password(SERVICE_NAME, "fmc_base_url", fmc_base_url)
+            keyring.set_password(SERVICE_NAME, "fmc_username", fmc_username)
+            keyring.set_password(SERVICE_NAME, "fmc_password", fmc_password)
+            keyring.set_password(SERVICE_NAME, "sync_interval_minutes", str(sync_interval_minutes))
+            log.info("Credentials and interval stored in OS keyring")
+            return True
+        except Exception as e:
+            log.error("Failed to store credentials: %s", e)
+            raise
+
+    @staticmethod
+    def get_credentials() -> dict:
+        try:
+            fmc_base_url = keyring.get_password(SERVICE_NAME, "fmc_base_url")
+            fmc_username = keyring.get_password(SERVICE_NAME, "fmc_username")
+            fmc_password = keyring.get_password(SERVICE_NAME, "fmc_password")
+            sync_interval_str = keyring.get_password(SERVICE_NAME, "sync_interval_minutes")
+            if not all([fmc_base_url, fmc_username, fmc_password, sync_interval_str]):
+                log.info("Credentials not found in keyring")
+                return None
+            return {"fmc_base_url": fmc_base_url, "fmc_username": fmc_username, "fmc_password": fmc_password, "sync_interval_minutes": int(sync_interval_str)}
+        except Exception as e:
+            log.error("Failed to retrieve credentials: %s", e)
+            return None
+
+    @staticmethod
+    def clear_credentials():
+        try:
+            for key in ["fmc_base_url", "fmc_username", "fmc_password", "sync_interval_minutes"]:
+                try:
+                    keyring.delete_password(SERVICE_NAME, key)
+                except keyring.errors.PasswordDeleteError:
+                    pass
+            log.info("Credentials cleared from keyring")
+            return True
+        except Exception as e:
+            log.error("Failed to clear credentials: %s", e)
+            raise
+
+class ConfigManager:
+    @staticmethod
+    def ensure_directories():
+        CONFIG_DIR.mkdir(parents=True, exist_ok=True)
+        LOG_DIR.mkdir(parents=True, exist_ok=True)
+
+    @staticmethod
+    def get_config_dir() -> Path:
+        ConfigManager.ensure_directories()
+        return CONFIG_DIR
+
+    @staticmethod
+    def get_log_dir() -> Path:
+        ConfigManager.ensure_directories()
+        return LOG_DIR
+
+    @staticmethod
+    def get_log_file() -> Path:
+        return ConfigManager.get_log_dir() / "bunny2fmc.log"
+
+    @staticmethod
+    def load_dynamic_object_name() -> str:
+        try:
+            if CONFIG_FILE.exists():
+                with open(CONFIG_FILE, "r") as f:
+                    data = json.load(f)
+                    return data.get("fmc_dynamic_name")
+        except Exception as e:
+            log.warning("Failed to load config: %s", e)
+        return None
+
+    @staticmethod
+    def save_dynamic_object_name(name: str):
+        try:
+            ConfigManager.ensure_directories()
+            data = {}
+            if CONFIG_FILE.exists():
+                with open(CONFIG_FILE, "r") as f:
+                    data = json.load(f)
+            data["fmc_dynamic_name"] = name
+            with open(CONFIG_FILE, "w") as f:
+                json.dump(data, f, indent=2)
+            log.info("Dynamic Object name saved")
+        except Exception as e:
+            log.error("Failed to save config: %s", e)
+            raise
+
+    @staticmethod
+    def save_include_ipv6(include: bool):
+        try:
+            ConfigManager.ensure_directories()
+            data = {}
+            if CONFIG_FILE.exists():
+                with open(CONFIG_FILE, "r") as f:
+                    data = json.load(f)
+            data["include_ipv6"] = include
+            with open(CONFIG_FILE, "w") as f:
+                json.dump(data, f, indent=2)
+            log.info("IPv6 preference saved")
+        except Exception as e:
+            log.error("Failed to save config: %s", e)
+            raise
+
+    @staticmethod
+    def load_include_ipv6() -> bool:
+        try:
+            if CONFIG_FILE.exists():
+                with open(CONFIG_FILE, "r") as f:
+                    data = json.load(f)
+                    return data.get("include_ipv6", False)
+        except Exception as e:
+            log.warning("Failed to load config: %s", e)
+        return False

bunny2fmc/sync_engine.py

@@ -0,0 +1,137 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""Core sync engine: Bunny edge IPs to FMC Dynamic Objects"""
+import json, ipaddress, logging
+from typing import List, Set, Iterable
+import requests
+from xml.etree import ElementTree as ET
+from wingpy import CiscoFMC
+
+log = logging.getLogger("bunny2fmc")
+BUNNY_IPV4_URL = "https://bunnycdn.com/api/system/edgeserverlist"
+BUNNY_IPV6_URL = "https://bunnycdn.com/api/system/edgeserverlist/ipv6"
+
+def _parse_possible_formats(body: str) -> List[str]:
+    try:
+        root = ET.fromstring(body)
+        vals = [el.text.strip() for el in root.findall(".//{*}string") if el.text]
+        if vals: return vals
+    except ET.ParseError: pass
+    try:
+        data = json.loads(body)
+        if isinstance(data, list): return [str(x).strip() for x in data if str(x).strip()]
+    except json.JSONDecodeError: pass
+    return [ln.strip() for ln in body.splitlines() if ln.strip()]
+
+def fetch_bunny_ips(include_ipv6: bool, verify_ssl: bool = False) -> Set[str]:
+    sess = requests.Session()
+    ips: Set[str] = set()
+    endpoints = [BUNNY_IPV4_URL] + ([BUNNY_IPV6_URL] if include_ipv6 else [])
+    for url in endpoints:
+        log.info("Fetching %s", url)
+        try:
+            r = sess.get(url, timeout=60, verify=verify_ssl, headers={"Accept": "application/xml, application/json, text/plain"})
+            r.raise_for_status()
+            for c in _parse_possible_formats(r.text):
+                try:
+                    if "/" in c: net = ipaddress.ip_network(c, strict=False)
+                    else:
+                        ip = ipaddress.ip_address(c)
+                        net = ipaddress.ip_network(f"{ip}/{32 if ip.version == 4 else 128}", strict=False)
+                    ips.add(str(net))
+                except ValueError: log.warning("Ignoring invalid Bunny entry: %r", c)
+        except Exception as e:
+            log.error("Error fetching %s: %s", url, e)
+            raise
+    if not ips: raise RuntimeError("No IPs fetched from Bunny")
+    return ips
+
+def get_all(fmc: CiscoFMC, path: str) -> List[dict]:
+    items: List[dict] = []
+    offset = 0
+    while True:
+        r = fmc.get(path + f"?offset={offset}&limit=1000&expanded=false")
+        r.raise_for_status()
+        batch = (r.json() or {}).get("items", [])
+        items.extend(batch)
+        if len(batch) < 1000: break
+        offset += 1000
+    return items
+
+def chunked(iterable: Iterable[str], size: int) -> Iterable[List[str]]:
+    buf = []
+    for x in iterable:
+        buf.append(x)
+        if len(buf) == size: yield buf; buf = []
+    if buf: yield buf
+
+def find_or_create_dynamic_object(fmc: CiscoFMC, name: str, description: str = "", dry_run: bool = False) -> dict:
+    items = get_all(fmc, "/api/fmc_config/v1/domain/{domainUUID}/object/dynamicobjects")
+    obj = next((it for it in items if it.get("name") == name), None)
+    if obj:
+        log.info("Found existing Dynamic Object: %s (id=%s)", name, obj.get("id"))
+        return obj
+    payload = {"type": "DynamicObject", "name": name, "objectType": "IP", "description": description or "Managed automatically from BunnyCDN edge server list."}
+    if dry_run:
+        log.info("[DRY_RUN] Would create Dynamic Object '%s'.", name)
+        return {"id": "DRYRUN-ID", "name": name, "type": "DynamicObject", "objectType": "IP"}
+    r = fmc.post("/api/fmc_config/v1/domain/{domainUUID}/object/dynamicobjects", data=payload)
+    r.raise_for_status()
+    result = r.json()
+    log.info("Created Dynamic Object: %s (id=%s)", name, result.get("id"))
+    return result
+
+def get_current_mappings(fmc: CiscoFMC, obj_id: str) -> Set[str]:
+    r = fmc.get("/api/fmc_config/v1/domain/{domainUUID}/object/dynamicobjects/{objectId}/mappings", path_params={"objectId": obj_id})
+    r.raise_for_status()
+    data = r.json() or {}
+    if isinstance(data, dict):
+        if "mappings" in data and isinstance(data["mappings"], list):
+            return set(str(x).strip() for x in data["mappings"] if str(x).strip())
+        if "items" in data and isinstance(data["items"], list):
+            out = set()
+            for it in data["items"]:
+                if isinstance(it, str): out.add(it.strip())
+                elif isinstance(it, dict) and "value" in it: out.add(str(it["value"]).strip())
+            return out
+    if isinstance(data, list): return set(str(x).strip() for x in data if str(x).strip())
+    return set()
+
+def post_mappings_update(fmc: CiscoFMC, add: List[str], remove: List[str], obj_id: str, chunk_size: int = 500, dry_run: bool = False):
+    if dry_run:
+        log.info("[DRY_RUN] Would ADD %d and REMOVE %d mappings.", len(add), len(remove))
+        return
+    endpoint = "/api/fmc_config/v1/domain/{domainUUID}/object/dynamicobjectmappings"
+    for batch in chunked(add, chunk_size):
+        payload = {"add": [{"mappings": batch, "dynamicObject": {"id": obj_id}}]}
+        r = fmc.post(endpoint, data=payload)
+        r.raise_for_status()
+        log.info("Added %d mappings.", len(batch))
+    for batch in chunked(remove, chunk_size):
+        payload = {"remove": [{"mappings": batch, "dynamicObject": {"id": obj_id}}]}
+        r = fmc.post(endpoint, data=payload)
+        r.raise_for_status()
+        log.info("Removed %d mappings.", len(batch))
+
+def sync(fmc_base_url: str, fmc_username: str, fmc_password: str, fmc_dynamic_name: str, include_ipv6: bool = False, verify_ssl: bool = False, dry_run: bool = False, chunk_size: int = 500) -> dict:
+    try:
+        log.info("Starting sync for Dynamic Object: %s", fmc_dynamic_name)
+        bunny_nets = fetch_bunny_ips(include_ipv6, verify_ssl)
+        log.info("Bunny: %d networks", len(bunny_nets))
+        fmc = CiscoFMC(base_url=fmc_base_url, username=fmc_username, password=fmc_password, verify=verify_ssl)
+        dyn = find_or_create_dynamic_object(fmc, fmc_dynamic_name, description="Dynamic Object auto-managed from BunnyCDN edge server list.", dry_run=dry_run)
+        dyn_id = dyn["id"]
+        log.info("Dynamic Object: %s (id=%s)", fmc_dynamic_name, dyn_id)
+        current = get_current_mappings(fmc, dyn_id)
+        desired = bunny_nets
+        to_add, to_remove = sorted(desired - current), sorted(current - desired)
+        log.info("Current: %d, Desired: %d, +Add: %d, -Remove: %d", len(current), len(desired), len(to_add), len(to_remove))
+        if not to_add and not to_remove:
+            log.info("No changes needed.")
+            return {"status": "success", "message": "No changes needed", "added": 0, "removed": 0, "total_current": len(current), "total_desired": len(desired)}
+        post_mappings_update(fmc, to_add, to_remove, dyn_id, chunk_size, dry_run)
+        log.info("Sync completed successfully.")
+        return {"status": "success", "message": "Sync completed", "added": len(to_add), "removed": len(to_remove), "total_current": len(current), "total_desired": len(desired)}
+    except Exception as e:
+        log.error("Sync failed: %s", str(e), exc_info=True)
+        return {"status": "error", "message": str(e), "added": 0, "removed": 0}

bunny2fmc-1.0.8.dist-info/METADATA

@@ -0,0 +1,176 @@
+Metadata-Version: 2.4
+Name: bunny2fmc
+Version: 1.0.8
+Summary: Sync BunnyCDN edge IPs to Cisco FMC Dynamic Objects with secure credential management and scheduling
+Author: Kasper Elsborg -Wingmen
+License: MIT
+Project-URL: Homepage, https://github.com/wingmen/bunny-sync-fmc
+Project-URL: Repository, https://github.com/wingmen/bunny-sync-fmc
+Keywords: bunny,fmc,cisco,edge-server,dynamic-object
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Intended Audience :: System Administrators
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Topic :: System :: Networking :: Firewalls
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: wingpy>=0.3.0
+Requires-Dist: requests>=2.25.0
+Requires-Dist: python-dotenv>=0.19.0
+Requires-Dist: keyring>=23.0.0
+Requires-Dist: keyrings.alt>=5.0
+Provides-Extra: dev
+Requires-Dist: pytest>=6.0; extra == "dev"
+Requires-Dist: black>=22.0; extra == "dev"
+Requires-Dist: flake8>=4.0; extra == "dev"
+Dynamic: license-file
+
+# 🐰 bunny2fmc
+
+Synkroniserer BunnyCDN edge server IP-adresser til en Cisco FMC Dynamic Object med sikker credential-gempling og automatisk scheduling.
+
+## Hvad gør scriptet?
+
+1. Henter aktuelle IPv4 (og evt. IPv6) adresser fra BunnyCDN's API
+2. Opretter/finder Dynamic Object på FMC
+3. Sammenligner nuværende mappings med Bunny's liste
+4. Tilføjer nye og fjerner forældede IP'er
+5. Ingen deploy nødvendig - Dynamic Objects opdateres on-the-fly
+6. **Sikker gempling**: Credentials gemmesto i OS Keyring (Windows Credential Manager / Linux Secret Service)
+7. **Automatisk scheduling**: Konfigurer interval ved første setup, køres via cron
+
+---
+
+## Installation
+
+### Option 1: Fra PyPI (Anbefalet)
+
+```bash
+# Opret virtual environment
+python3 -m venv venv
+
+# Aktivér venv (VIGTIG - skal gøres før hver brug!)
+source venv/bin/activate    # Linux/macOS
+# eller
+venv\Scripts\activate       # Windows
+
+# Installer bunny2fmc
+pip install bunny2fmc
+
+# Verificer installation
+bunny2fmc --version
+bunny2fmc --help
+```
+
+### Option 2: Fra source (Local development)
+
+```bash
+# Clone repository
+cd /path/to/Bunny_Sync_FMC
+
+# Opret virtual environment
+python3 -m venv venv
+
+# Aktivér venv (VIGTIG!)
+source venv/bin/activate    # Linux/macOS
+# eller
+venv\Scripts\activate       # Windows
+
+# Installer som development package
+pip install -e .
+
+# Verificer installation
+bunny2fmc --version
+```
+
+### ⚠️ VIGTIG: Aktivér venv før brug
+
+**Du SKAL aktivere venv før du kan bruge bunny2fmc!**
+
+```bash
+# Linux/macOS
+source venv/bin/activate
+
+# Windows
+venv\Scripts\activate
+
+# Nu kan du bruge kommandoen:
+bunny2fmc --help
+```
+
+Når venv er aktiveret, vises `(venv)` i din prompt
+---
+
+## Distribution Strategy
+
+### Repository Struktur
+
+- **Privat GitHub** (`https://github.com/IronKeyVault/Bunny_Sync_FMC`): 
+  - Source of truth for alt udvikling
+  - Indeholder hele kodebase (gamle scripts, notes, configs)
+  - Kun for interne team medlemmer
+  
+- **PyPI** (`https://pypi.org/project/bunny2fmc`):
+  - Public distribution punkt
+  - Alle brugere kan installere med: `pip install bunny2fmc`
+  - Synkroniseret fra privat repo
+
+### Release Workflow
+
+Når du er klar til at udgive en ny version:
+
+```bash
+./release.sh
+```
+
+Scriptet vil:
+1. Spørge for nyt versionsnummer (f.eks. 1.0.2)
+2. Opdatere `pyproject.toml` og `bunny2fmc/__init__.py`
+3. Committe og pushe til GitHub
+4. Bygge pakken
+5. Uploade til PyPI
+
+**Eksempel:**
+```
+./release.sh
+Enter new version (e.g., 1.0.2): 1.0.2
+✓ Release v1.0.2 complete
+```
+
+---
+
+## Hvornår kan jeg slette den gamle public repo?
+
+Du kan slette `https://github.com/IronKeyVault/bunny2fmc` når:
+
+1. ✅ **PyPI har den seneste version** 
+   - Verificer på https://pypi.org/project/bunny2fmc/
+   - Alle nye releases går direkte til PyPI via `release.sh`
+
+2. ✅ **Ingen users refererer til det**
+   - Hvis andre har installeringer fra Git URL, skal de updateres til:
+   - `pip install bunny2fmc` (fra PyPI i stedet)
+
+3. ✅ **Du er sikker på at PyPI er det eneste public distribution point**
+   - Alt udvikling fortsætter i privat repo
+   - Releases håndteres via `./release.sh`
+
+### Sletning
+
+Når du er 100% sikker, kan du slette repoet:
+
+1. Gå til https://github.com/IronKeyVault/bunny2fmc
+2. Settings → Danger Zone → Delete Repository
+3. Bekræft ved at skrive repo-navnet
+
+**Efter sletning:**
+- Alt udvikling/history ligger stadig på privat repo
+- Alle brugere bruger PyPI (bedst praksis)
+- Enklere repository-management
+

bunny2fmc-1.0.8.dist-info/RECORD

@@ -0,0 +1,10 @@
+bunny2fmc/__init__.py,sha256=fVsHsYtI5haE_NeyaMKlYiaAROUctiIYibLRdvIyPTg,133
+bunny2fmc/cli.py,sha256=p8Mhve3L9_6xEtu2712LLp7S3nC8hfyXJBc-wmC7UtY,10111
+bunny2fmc/config.py,sha256=rvpkAGZv2NaRChXyO9u4dnQl5wnvExToMvlCIJZMlpQ,4803
+bunny2fmc/sync_engine.py,sha256=zCAJ0LrKgHQ6zOWHVOfTvvlHgNkILYyFq0ftdPC3Pt4,7024
+bunny2fmc-1.0.8.dist-info/licenses/LICENSE,sha256=2_vaDeZJ15RDU_6C1r5IJ7urPUt4hHeMrUd92xwWcwQ,1080
+bunny2fmc-1.0.8.dist-info/METADATA,sha256=EQXJepPA3AAa1Q38W-o_DPQx7fcTVUH0vC4_BpB05d8,4766
+bunny2fmc-1.0.8.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+bunny2fmc-1.0.8.dist-info/entry_points.txt,sha256=ZjZFEAAugvnna7HHbYcfivJGJway3qgM-S-B2lf9akI,49
+bunny2fmc-1.0.8.dist-info/top_level.txt,sha256=7a2i3_fKlFFNKUmSEDFbwXI_CXPEcUsrIisHNLEAXtM,10
+bunny2fmc-1.0.8.dist-info/RECORD,,

bunny2fmc-1.0.8.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.9.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

bunny2fmc-1.0.8.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+bunny2fmc = bunny2fmc.cli:main

bunny2fmc-1.0.8.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Kasper Elsborg -Wingmen
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

bunny2fmc-1.0.8.dist-info/top_level.txt

@@ -0,0 +1 @@
+bunny2fmc