sfacts 2.3.0__py3-none-any.whl

sfacts/__init__.py

@@ -0,0 +1,17 @@
+"""
+SFacts - Network Discovery and Fact Collection Tool
+
+A modern network automation tool leveraging proven libraries:
+- Netmiko for SSH connections and auto-detection
+- NAPALM for vendor-agnostic device interaction
+- ntc-templates for TextFSM parsing
+- Nornir for parallel execution
+"""
+
+__version__ = "2.3.0"
+__author__ = "Milan Zapletal"
+
+from .core.discovery import NetworkDiscovery
+from .core.scanner import SubnetScanner
+
+__all__ = ["NetworkDiscovery", "SubnetScanner"]

sfacts/cli/__init__.py

@@ -0,0 +1,8 @@
+"""
+Command-line interface for simple-facts network discovery tool.
+"""
+
+from .discover import discover
+from .main import cli
+
+__all__ = ["cli", "discover"]

sfacts/cli/discover.py

@@ -0,0 +1,182 @@
+"""
+Discovery command for network device scanning and identification.
+"""
+
+import os
+from datetime import datetime
+from typing import Optional
+
+import click
+
+from ..core.discovery import NetworkDiscovery
+from ..utils.auth import CredentialManager
+from ..utils.logger import get_cli_logger
+
+logger = get_cli_logger()
+
+
+@click.command()
+@click.option("--subnet", help="Subnet to scan (e.g., 192.168.1.0/24)")
+@click.option("--tunnel-host", help="SSH tunnel host (e.g., localhost for testing)")
+@click.option("--tunnel-ports", help="SSH tunnel port range (e.g., 2101-2116)")
+@click.option("--username", help="SSH username (or set NETOPS_USERNAME env var)")
+@click.option("--password", help="SSH password (or set NETOPS_PASSWORD env var)")
+@click.option("--secret", help="Enable secret (optional, or set NETOPS_SECRET env var)")
+@click.option("--output", help="Output file (default: disco_results_TIMESTAMP.json)")
+@click.option("--output-dir", help="Output directory for results (creates if not exists)")
+@click.option("--timeout", default=10, help="SSH timeout in seconds")
+@click.option("--workers", default=20, help="Number of parallel workers")
+@click.option("--no-save", is_flag=True, help="Do not save results to file")
+def discover(
+    subnet: Optional[str],
+    tunnel_host: Optional[str],
+    tunnel_ports: Optional[str],
+    username: Optional[str],
+    password: Optional[str],
+    secret: Optional[str],
+    output: Optional[str],
+    output_dir: Optional[str],
+    timeout: int,
+    workers: int,
+    no_save: bool,
+) -> None:
+    """
+    Discover network devices and identify them using Netmiko SSHDetect.
+
+    This command supports two modes:
+    1. Subnet scanning: Scans subnet for devices with open SSH ports
+    2. SSH tunnel mode: Tests devices through SSH tunnel (localhost + port range)
+
+    Examples:
+
+        # Basic subnet discovery
+        sfacts discover --subnet 192.168.1.0/24
+
+        # Save results to specific directory
+        sfacts discover --subnet 192.168.1.0/24 --output-dir /path/to/results
+
+        # SSH tunnel mode for testing
+        sfacts discover --tunnel-host localhost --tunnel-ports 2101-2116
+
+        # High-performance scanning with custom output
+        sfacts discover --subnet 10.0.0.0/16 --workers 50 --timeout 15 --output-dir ./network_scans
+    """
+
+    logger.info(" SFacts - Network Discovery Tool")
+
+    # Validate mode selection
+    if not subnet and not (tunnel_host and tunnel_ports):
+        logger.error("Either --subnet or both --tunnel-host and --tunnel-ports must be specified")
+        raise click.Abort()
+
+    if subnet and (tunnel_host or tunnel_ports):
+        logger.error("Cannot use both subnet and tunnel mode simultaneously")
+        raise click.Abort()
+
+    # Display mode
+    if subnet:
+        logger.info(f"Mode: Subnet scanning - {subnet}")
+    else:
+        logger.info(f"Mode: SSH tunnel - {tunnel_host} ports {tunnel_ports}")
+
+    try:
+        # Get credentials
+        cred_manager = CredentialManager()
+        credentials = cred_manager.get_credentials(
+            username=username, password=password, secret=secret, prompt=True
+        )
+
+        # Validate credentials
+        if not cred_manager.validate_credentials(credentials):
+            logger.error("Invalid credentials provided")
+            raise click.Abort()
+
+        logger.success(f"Using credentials for user: {credentials['username']}")
+
+        # Initialize discovery engine
+        discovery = NetworkDiscovery(credentials=credentials, timeout=timeout, max_workers=workers)
+
+        # Perform discovery based on mode
+        if subnet:
+            # Store subnet for results
+            discovery._last_subnet = subnet
+
+            logger.info("\nDiscovery Parameters:")
+            logger.info(f"  • Timeout: {timeout}s")
+            logger.info(f"  • Workers: {workers}")
+            logger.info(f"  • Target: {subnet}")
+
+            devices = discovery.discover_subnet(subnet)
+        else:
+            # SSH tunnel mode
+            logger.info("\nTunnel Discovery Parameters:")
+            logger.info(f"  • Timeout: {timeout}s")
+            logger.info(f"  • Workers: {workers}")
+            logger.info(f"  • Host: {tunnel_host}")
+            logger.info(f"  • Ports: {tunnel_ports}")
+
+            assert tunnel_host is not None and tunnel_ports is not None
+            devices = discovery.discover_tunnel(tunnel_host, tunnel_ports)
+
+        # Display results
+        if devices:
+            logger.success("Discovery completed successfully!")
+            logger.success(f"Found {len(devices)} network devices")
+
+            # Show device details
+            logger.info("\nDiscovered Devices:")
+            for device in devices:
+                logger.info(f"  • {device['host']} - {device['device_type']}")
+        else:
+            logger.warning(f"\n No devices found in {subnet}")
+            logger.warning("This could mean:")
+            logger.warning("  • No devices have SSH enabled")
+            logger.warning("  • Firewall is blocking SSH access")
+            logger.warning("  • Credentials are incorrect")
+
+        # Save results unless disabled
+        if not no_save:
+            # Handle output directory and filename
+            if output_dir:
+                # Create output directory if it doesn't exist
+                os.makedirs(output_dir, exist_ok=True)
+
+                if output:
+                    # If both output-dir and output are specified, combine them
+                    output_path = os.path.join(output_dir, os.path.basename(output))
+                else:
+                    # Generate default filename in the specified directory
+                    timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+                    output_path = os.path.join(output_dir, f"disco_results_{timestamp}.json")
+            else:
+                # Use output as-is or generate default in current directory
+                if not output:
+                    timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+                    output_path = f"disco_results_{timestamp}.json"
+                else:
+                    output_path = output
+
+            discovery.save_results(output_path)
+
+            # Show file info
+            if os.path.exists(output_path):
+                file_size = os.path.getsize(output_path)
+                logger.success(f"Results saved to {output_path}")
+                logger.info(f" File size: {file_size:,} bytes")
+
+        # Show next steps
+        if devices:
+            logger.info("\nNext Steps:")
+            logger.info("• Phase 2: Fact collection (coming soon)")
+            logger.info("• Review the JSON output for detailed device information")
+            logger.info("• Use the discovered devices for network automation tasks")
+
+        logger.success("\n✅ Discovery process completed")
+
+    except KeyboardInterrupt:
+        logger.warning("Discovery interrupted by user")
+        raise click.Abort() from None
+    except Exception as e:
+        logger.error(f"✗ Discovery failed: {str(e)}")
+        logger.error("Aborted!")
+        raise click.Abort() from e

sfacts/cli/export.py

@@ -0,0 +1,177 @@
+"""
+CLI command for exporting inventory from collected facts.
+"""
+
+import json
+from pathlib import Path
+from typing import Optional
+
+import click
+from rich.console import Console
+from rich.panel import Panel
+from rich.table import Table
+
+from ..core.inventory import NornirInventoryExporter
+from ..utils.logger import get_cli_logger
+
+console = Console()
+logger = get_cli_logger()
+
+
+@click.command()
+@click.option(
+    "--input-file",
+    "-i",
+    type=click.Path(exists=True, path_type=Path),
+    help="Input facts JSON file to export from",
+)
+@click.option(
+    "--output-dir",
+    "-o",
+    default="inventory",
+    type=click.Path(path_type=Path),
+    help="Output directory for inventory files (default: inventory)",
+)
+@click.option(
+    "--format",
+    "export_format",
+    type=click.Choice(["nornir"]),
+    default="nornir",
+    help="Export format (default: nornir)",
+)
+@click.option(
+    "--include-credentials/--no-credentials",
+    default=False,
+    help="Include default credentials in inventory (default: no)",
+)
+@click.option(
+    "--latest/--no-latest",
+    default=True,
+    help="Use latest facts file if no input specified (default: yes)",
+)
+def export_inventory(
+    input_file: Optional[Path],
+    output_dir: Path,
+    export_format: str,
+    include_credentials: bool,
+    latest: bool,
+) -> None:
+    """
+    Export collected device facts to inventory format.
+
+    Converts facts collection results into network automation inventory
+    formats like Nornir for use with automation frameworks.
+    """
+    console.print(
+        Panel.fit(
+            "[bold blue]Simple Facts - Inventory Export[/bold blue]",
+            border_style="blue",
+        )
+    )
+
+    try:
+        # Determine input file
+        if not input_file:
+            if latest:
+                input_file = _find_latest_facts_file()
+                if not input_file:
+                    console.print("[red]❌ No facts files found in output/ directory[/red]")
+                    raise click.Abort()
+                console.print(f"[green]📁 Using latest facts file: {input_file}[/green]")
+            else:
+                console.print("[red]❌ No input file specified[/red]")
+                raise click.Abort()
+
+        # Load facts data
+        console.print(f"[blue]📖 Loading facts from {input_file}...[/blue]")
+        with open(input_file) as f:
+            facts_data = json.load(f)
+
+        # Validate facts data
+        if "devices" not in facts_data:
+            console.print("[red]❌ Invalid facts file format - missing 'devices' key[/red]")
+            raise click.Abort()
+
+        devices_raw = facts_data["devices"]
+        # Convert dict to list and filter successful devices
+        successful_devices = []
+        for _device_key, device_data in devices_raw.items():
+            if isinstance(device_data, dict):
+                connection_info = device_data.get("connection_info", {})
+                if connection_info.get("connection_successful", False):
+                    successful_devices.append(device_data)
+
+        if not successful_devices:
+            console.print("[red]❌ No successful device collections found in facts file[/red]")
+            raise click.Abort()
+
+        console.print(f"[green]✅ Found {len(successful_devices)} devices to export[/green]")
+
+        # Export based on format
+        if export_format == "nornir":
+            exporter = NornirInventoryExporter()
+
+            console.print(f"[blue]🔄 Exporting to Nornir format in {output_dir}/...[/blue]")
+            files_created = exporter.export_inventory(
+                facts_data, str(output_dir), include_credentials
+            )
+
+            # Display results
+            _display_export_results(files_created, exporter, facts_data)
+
+        else:
+            console.print(f"[red]❌ Unsupported export format: {export_format}[/red]")
+            raise click.Abort()
+
+        console.print("\n[bold green]🎉 Inventory export completed successfully![/bold green]")
+
+    except Exception as e:
+        console.print(f"[red]❌ Export failed: {e}[/red]")
+        raise RuntimeError(f"Export failed: {e}") from e
+
+
+def _find_latest_facts_file() -> Optional[Path]:
+    """Find the most recent facts file in output directory."""
+    output_dir = Path("output")
+    if not output_dir.exists():
+        return None
+
+    facts_files = list(output_dir.glob("facts_results_*.json"))
+    if not facts_files:
+        return None
+
+    # Sort by modification time, newest first
+    return max(facts_files, key=lambda f: f.stat().st_mtime)
+
+
+def _display_export_results(
+    files_created: dict, exporter: NornirInventoryExporter, facts_data: dict
+) -> None:
+    """Display export results in a formatted table."""
+
+    # Files created table
+    table = Table(title="📁 Files Created", show_header=True, header_style="bold blue")
+    table.add_column("File Type", style="cyan")
+    table.add_column("Path", style="green")
+    table.add_column("Size", style="yellow")
+
+    for file_type, file_path in files_created.items():
+        file_size = Path(file_path).stat().st_size
+        size_str = f"{file_size:,} bytes"
+        table.add_row(file_type.title(), file_path, size_str)
+
+    console.print(table)
+
+    # Summary report
+    summary = exporter.generate_summary_report(facts_data)
+    console.print(
+        Panel(
+            summary,
+            title="📊 Export Summary",
+            border_style="green",
+        )
+    )
+
+
+if __name__ == "__main__":
+    export_inventory()

sfacts/cli/facts.py

@@ -0,0 +1,219 @@
+"""
+Facts collection command for detailed device information gathering.
+"""
+
+import json
+import os
+from datetime import datetime
+from typing import Optional
+
+import click
+
+from ..core.discovery import NetworkDiscovery
+from ..utils.auth import CredentialManager
+from ..utils.logger import get_collector_logger
+
+logger = get_collector_logger()
+
+
+@click.command()
+@click.option("--input", "input_file", help="Input discovery file (JSON)")
+@click.option("--subnet", help="Subnet to discover and collect facts from")
+@click.option("--username", help="SSH username (or set NETOPS_USERNAME env var)")
+@click.option("--password", help="SSH password (or set NETOPS_PASSWORD env var)")
+@click.option("--secret", help="Enable secret (optional, or set NETOPS_SECRET env var)")
+@click.option("--output", help="Output file (default: facts_results_TIMESTAMP.json)")
+@click.option("--output-dir", help="Output directory for results (creates if not exists)")
+@click.option("--timeout", default=10, help="SSH timeout in seconds")
+@click.option("--workers", default=10, help="Number of parallel workers")
+@click.option("--no-save", is_flag=True, help="Do not save results to file")
+def facts(
+    input_file: Optional[str],
+    subnet: Optional[str],
+    username: Optional[str],
+    password: Optional[str],
+    secret: Optional[str],
+    output: Optional[str],
+    output_dir: Optional[str],
+    timeout: int,
+    workers: int,
+    no_save: bool,
+) -> None:
+    """
+    Collect detailed facts from network devices.
+
+    This command can work in two modes:
+    1. Use existing discovery results (--input)
+    2. Discover and collect facts in one step (--subnet)
+
+    Examples:
+
+        # Collect facts from previous discovery
+        sfacts facts --input discovery_results.json
+
+        # Save results to specific directory
+        sfacts facts --input discovery_results.json --output-dir /path/to/results
+
+        # Discover and collect facts in one step
+        sfacts facts --subnet 192.168.1.0/24
+
+        # Combine discovery and facts with custom output directory
+        sfacts facts --subnet 192.168.1.0/24 --output-dir ./network_facts
+
+        # Use environment variables for credentials
+        export NETOPS_USERNAME=admin
+        export NETOPS_PASSWORD=admin
+        sfacts facts --subnet 10.0.0.0/24 --output-dir ./results
+    """
+
+    logger.info("🔍 SFacts - Enhanced Fact Collection")
+
+    try:
+        # Get credentials
+        cred_manager = CredentialManager()
+        credentials = cred_manager.get_credentials(
+            username=username, password=password, secret=secret, prompt=True
+        )
+
+        # Validate credentials
+        if not cred_manager.validate_credentials(credentials):
+            logger.error("✗ Invalid credentials provided")
+            raise click.Abort()
+
+        logger.success(f"✓ Using credentials for user: {credentials['username']}")
+
+        devices = []
+
+        # Mode 1: Load devices from existing discovery file
+        if input_file:
+            logger.info(f"📂 Loading devices from {input_file}")
+
+            if not os.path.exists(input_file):
+                logger.error(f"✗ Input file not found: {input_file}")
+                raise click.Abort()
+
+            with open(input_file) as f:
+                discovery_data = json.load(f)
+
+            # Extract devices from discovery format
+            if "devices" in discovery_data:
+                for host, device_info in discovery_data["devices"].items():
+                    device_entry = {
+                        "host": device_info.get("host", host.split(":")[0]),
+                        "device_type": device_info.get("device_type"),
+                        "platform": device_info.get("platform"),
+                        "credentials": credentials,
+                    }
+
+                    # Add port if specified in device info
+                    if "port" in device_info:
+                        device_entry["port"] = device_info["port"]
+
+                    devices.append(device_entry)
+
+            logger.success(f"✓ Loaded {len(devices)} devices from discovery file")
+
+        # Mode 2: Discover devices first, then collect facts
+        elif subnet:
+            logger.info(f"🔍 Discovering devices in {subnet}")
+
+            # Initialize discovery engine
+            discovery = NetworkDiscovery(
+                credentials=credentials, timeout=timeout, max_workers=workers
+            )
+
+            # Discover devices
+            devices = discovery.discover_subnet(subnet)
+
+            if not devices:
+                logger.warning(f"⚠ No devices found in {subnet}")
+                return
+
+        else:
+            logger.error("✗ Either --input or --subnet must be specified")
+            raise click.Abort()
+
+        if not devices:
+            logger.warning("⚠ No devices available for fact collection")
+            return
+
+        # Initialize discovery engine for fact collection
+        discovery = NetworkDiscovery(credentials=credentials, timeout=timeout, max_workers=workers)
+
+        # Collect detailed facts
+        logger.info("Fact Collection Parameters:")
+        logger.info(f"  • Devices: {len(devices)}")
+        logger.info(f"  • Timeout: {timeout}s")
+        logger.info(f"  • Workers: {workers}")
+
+        fact_results = discovery.collect_facts(devices)
+
+        # Display summary
+        if fact_results and "collection_summary" in fact_results:
+            summary = fact_results["collection_summary"]
+
+            logger.success("📊 Fact Collection Summary")
+            logger.info(f"Total Devices: {summary.get('total_devices', 0)}")
+            logger.info(f"Successful Collections: {summary.get('successful_devices', 0)}")
+            logger.info(f"Failed Collections: {summary.get('failed_devices', 0)}")
+
+            # Show device details
+            if fact_results.get("devices"):
+                logger.info("Device Facts Collected:")
+                for host, device_facts in fact_results["devices"].items():
+                    if device_facts.get("connection_info", {}).get("connection_successful", False):
+                        basic_facts = device_facts.get("basic_facts", {})
+                        hostname = basic_facts.get("hostname", "unknown")
+                        model = basic_facts.get("model", "unknown")
+                        version = basic_facts.get("software_version", "unknown")
+                        logger.info(f"  • {host} - {hostname} ({model}) - {version}")
+                    else:
+                        logger.error(f"  • {host} - Connection failed")
+
+        # Save results unless disabled
+        if not no_save:
+            # Handle output directory and filename
+            if output_dir:
+                # Create output directory if it doesn't exist
+                os.makedirs(output_dir, exist_ok=True)
+
+                if output:
+                    # If both output-dir and output are specified, combine them
+                    output_path = os.path.join(output_dir, os.path.basename(output))
+                else:
+                    # Generate default filename in the specified directory
+                    timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+                    output_path = os.path.join(output_dir, f"facts_results_{timestamp}.json")
+            else:
+                # Use output as-is or generate default in current directory
+                if not output:
+                    timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+                    output_path = f"facts_results_{timestamp}.json"
+                else:
+                    output_path = output
+
+            with open(output_path, "w") as f:
+                json.dump(fact_results, f, indent=2, default=str)
+
+            logger.success(f"✅ Results saved to {output_path}")
+
+            # Show file info
+            if os.path.exists(output_path):
+                file_size = os.path.getsize(output_path)
+                logger.info(f"📄 File size: {file_size:,} bytes")
+
+        # Show next steps
+        logger.info("Enhanced Data Available:")
+        logger.info("• Device hostnames, models, and software versions")
+        logger.info("• Command outputs (show version, show inventory, etc.)")
+        logger.info("• Connection and timing metadata")
+        logger.info("• Structured device facts for automation")
+
+    except KeyboardInterrupt:
+        logger.warning("⚠ Fact collection interrupted by user")
+        raise click.Abort() from None
+    except Exception as e:
+        logger.error(f"✗ Fact collection failed: {str(e)}")
+        raise click.Abort() from e
+
+    logger.success("✅ Fact collection completed")

sfacts/cli/main.py

@@ -0,0 +1,39 @@
+"""
+Main CLI entry point for sfacts network discovery tool.
+"""
+
+import click
+from rich.console import Console
+
+from .discover import discover
+from .export import export_inventory
+from .facts import facts
+from .netbox import netbox
+
+console = Console()
+
+
+@click.group()
+@click.version_option(version="2.1.0", prog_name="sfacts")
+def cli() -> None:
+    """
+    SFacts - Network Discovery and Fact Collection Tool
+
+    A modern network automation tool leveraging proven libraries:
+    - Netmiko for SSH connections and auto-detection
+    - NAPALM for vendor-agnostic device interaction
+    - ntc-templates for TextFSM parsing
+    - Nornir for parallel execution
+    """
+    pass
+
+
+# Add subcommands
+cli.add_command(discover)
+cli.add_command(facts)
+cli.add_command(export_inventory)
+cli.add_command(netbox)
+
+
+if __name__ == "__main__":
+    cli()