netbox-vcenter-server 0.2.0__py3-none-any.whl

netbox_vcenter/__init__.py

@@ -0,0 +1,59 @@
+"""
+NetBox vCenter Plugin
+
+Provides a dashboard for viewing and importing VMs from VMware vCenter servers.
+Supports multiple vCenter servers with per-server caching and VM import to NetBox.
+"""
+
+from netbox.plugins import PluginConfig
+
+__version__ = "0.2.0"
+
+
+class VcenterConfig(PluginConfig):
+    """Plugin configuration for NetBox vCenter integration."""
+
+    name = "netbox_vcenter"
+    verbose_name = "vCenter"
+    description = "View and import VMs from VMware vCenter servers"
+    version = __version__
+    author = "sieteunoseis"
+    author_email = "jeremy.worden@gmail.com"
+    base_url = "vcenter"
+    min_version = "4.0.0"
+
+    # Required settings - plugin won't load without these
+    required_settings = []
+
+    # Default configuration values
+    default_settings = {
+        # List of vCenter servers to choose from
+        "vcenter_servers": [],
+        # Connection settings
+        "timeout": 60,  # Connection timeout in seconds (longer for MFA)
+        "verify_ssl": False,  # SSL verification (False for self-signed certs)
+        # MFA/2FA settings
+        "mfa_enabled": False,  # Whether to show MFA warning
+        "mfa_label": "MFA",  # Short label: "Duo", "2FA", "MFA", etc.
+        "mfa_message": "Check your authenticator after clicking Connect & Sync.",
+        # Name matching for duplicate detection
+        # Options: "exact" (case-insensitive full name), "hostname" (strip domain), "regex" (custom pattern)
+        "name_match_mode": "exact",
+        # Regex pattern to extract the match portion from VM name (used when name_match_mode is "regex")
+        # Example: r"^([^.]+)" extracts hostname (same as "hostname" mode)
+        # Example: r"^(\w+\d+)" extracts letters followed by numbers
+        "name_match_pattern": r"^([^.]+)",
+        # Import/sync settings
+        # Whether to normalize VM names on import (strip domain, lowercase)
+        # e.g., "WebServer01.example.com" -> "webserver01"
+        "normalize_imported_name": True,
+        # Tag slug to apply to imported/synced VMs (must exist in NetBox, or leave empty)
+        "default_tag": "",
+        # Optional default role slug for imported VMs (must exist in NetBox, or leave empty)
+        "default_role": "",
+        # Optional default platform slug for imported VMs (must exist in NetBox, or leave empty)
+        "default_platform": "",
+    }
+
+
+config = VcenterConfig

netbox_vcenter/api/__init__.py

@@ -0,0 +1 @@
+"""API module for NetBox Vcenter plugin."""

netbox_vcenter/api/urls.py

@@ -0,0 +1,5 @@
+"""API URL configuration for NetBox Vcenter plugin."""
+
+from django.urls import path
+
+urlpatterns = []

netbox_vcenter/client.py

@@ -0,0 +1,247 @@
+"""vCenter API client using pyvmomi."""
+
+import logging
+import ssl
+from typing import Optional
+
+from pyVim.connect import Disconnect, SmartConnect
+from pyVmomi import vim
+
+logger = logging.getLogger(__name__)
+
+
+class VCenterClient:
+    """Client for connecting to VMware vCenter and fetching VM data."""
+
+    def __init__(self, server: str, username: str, password: str, verify_ssl: bool = False):
+        """
+        Initialize vCenter client.
+
+        Args:
+            server: vCenter server hostname
+            username: vCenter username (e.g., domain\\user)
+            password: vCenter password
+            verify_ssl: Whether to verify SSL certificates
+        """
+        self.server = server
+        self.username = username
+        self.password = password
+        self.verify_ssl = verify_ssl
+        self.service_instance = None
+        self.content = None
+
+    def connect(self):
+        """
+        Connect to vCenter server.
+
+        Returns:
+            ServiceInstance object
+
+        Raises:
+            Exception: If connection fails
+        """
+        logger.info(f"Connecting to vCenter: {self.server}")
+
+        ssl_context = None
+        if not self.verify_ssl:
+            ssl_context = ssl.SSLContext(ssl.PROTOCOL_TLS_CLIENT)
+            ssl_context.check_hostname = False
+            ssl_context.verify_mode = ssl.CERT_NONE
+
+        self.service_instance = SmartConnect(
+            host=self.server,
+            user=self.username,
+            pwd=self.password,
+            sslContext=ssl_context,
+        )
+
+        self.content = self.service_instance.RetrieveContent()
+        logger.info(f"Connected to vCenter: {self.content.about.fullName}")
+
+        return self.service_instance
+
+    def disconnect(self):
+        """Disconnect from vCenter server."""
+        if self.service_instance:
+            logger.info(f"Disconnecting from vCenter: {self.server}")
+            Disconnect(self.service_instance)
+            self.service_instance = None
+            self.content = None
+
+    def _get_objects_of_type(self, obj_type):
+        """Get all objects of a specific type from vCenter."""
+        view_mgr = self.content.viewManager.CreateContainerView(
+            self.content.rootFolder, [obj_type], True
+        )
+        try:
+            return list(view_mgr.view)
+        finally:
+            view_mgr.Destroy()
+
+    def get_vcenter_info(self) -> dict:
+        """Get vCenter server information."""
+        about = self.content.about
+        return {
+            "name": about.name,
+            "full_name": about.fullName,
+            "version": about.version,
+            "build": about.build,
+            "os_type": about.osType,
+        }
+
+    def fetch_all_vms(self) -> list:
+        """
+        Fetch all virtual machines from vCenter.
+
+        Returns:
+            List of VM dictionaries with details
+        """
+        logger.info(f"Fetching VMs from {self.server}")
+
+        vms = self._get_objects_of_type(vim.VirtualMachine)
+        vm_list = []
+
+        for vm in vms:
+            try:
+                vm_data = {
+                    "name": vm.name,
+                    "power_state": "on" if vm.runtime.powerState == "poweredOn" else "off",
+                    "vcpus": None,
+                    "memory_mb": None,
+                    "disk_gb": None,
+                    "cluster": None,
+                    "datacenter": None,
+                    "guest_os": None,
+                    "uuid": None,
+                    "ip_addresses": [],
+                    "primary_ip": None,
+                    "interfaces": [],
+                }
+
+                # Get hardware config
+                if vm.config:
+                    vm_data["vcpus"] = vm.config.hardware.numCPU
+                    vm_data["memory_mb"] = vm.config.hardware.memoryMB
+                    vm_data["guest_os"] = vm.config.guestFullName
+                    vm_data["uuid"] = vm.config.uuid
+
+                    # Calculate total disk capacity
+                    disk_devices = [
+                        device
+                        for device in vm.config.hardware.device
+                        if isinstance(device, vim.vm.device.VirtualDisk)
+                    ]
+                    if disk_devices:
+                        total_kb = sum(d.capacityInKB for d in disk_devices)
+                        vm_data["disk_gb"] = round(total_kb / 1048576)  # KB to GB
+
+                # Get network interfaces and IP addresses from VMware Tools
+                if vm.guest:
+                    # Primary IP from guest info
+                    if vm.guest.ipAddress:
+                        vm_data["primary_ip"] = vm.guest.ipAddress
+                        vm_data["ip_addresses"].append(vm.guest.ipAddress)
+
+                    # Get all network interfaces
+                    if vm.guest.net:
+                        for nic in vm.guest.net:
+                            interface = {
+                                "name": nic.network or "Unknown",
+                                "mac": nic.macAddress,
+                                "connected": nic.connected,
+                                "ip_addresses": [],
+                            }
+                            if nic.ipConfig and nic.ipConfig.ipAddress:
+                                for ip_info in nic.ipConfig.ipAddress:
+                                    ip = ip_info.ipAddress
+                                    interface["ip_addresses"].append(ip)
+                                    if ip not in vm_data["ip_addresses"]:
+                                        vm_data["ip_addresses"].append(ip)
+                            vm_data["interfaces"].append(interface)
+
+                # Get cluster and datacenter
+                if vm.runtime.host:
+                    host = vm.runtime.host
+                    if host.parent and isinstance(host.parent, vim.ClusterComputeResource):
+                        vm_data["cluster"] = host.parent.name
+                    # Walk up to find datacenter
+                    parent = host.parent
+                    while parent:
+                        if isinstance(parent, vim.Datacenter):
+                            vm_data["datacenter"] = parent.name
+                            break
+                        parent = getattr(parent, "parent", None)
+
+                vm_list.append(vm_data)
+
+            except Exception as e:
+                logger.warning(f"Error processing VM {vm.name}: {e}")
+                continue
+
+        logger.info(f"Fetched {len(vm_list)} VMs from {self.server}")
+        return vm_list
+
+    def fetch_clusters(self) -> list:
+        """
+        Fetch all clusters from vCenter.
+
+        Returns:
+            List of cluster dictionaries
+        """
+        clusters = self._get_objects_of_type(vim.ClusterComputeResource)
+        cluster_list = []
+
+        for cluster in clusters:
+            cluster_list.append(
+                {
+                    "name": cluster.name,
+                    "host_count": len(cluster.host) if cluster.host else 0,
+                }
+            )
+
+        return cluster_list
+
+    def fetch_datacenters(self) -> list:
+        """
+        Fetch all datacenters from vCenter.
+
+        Returns:
+            List of datacenter dictionaries
+        """
+        datacenters = self._get_objects_of_type(vim.Datacenter)
+        return [{"name": dc.name} for dc in datacenters]
+
+
+def connect_and_fetch(
+    server: str, username: str, password: str, verify_ssl: bool = False
+) -> tuple[Optional[list], Optional[str]]:
+    """
+    Connect to vCenter and fetch all VMs.
+
+    This is a convenience function that handles connection/disconnection.
+
+    Args:
+        server: vCenter server hostname
+        username: vCenter username
+        password: vCenter password
+        verify_ssl: Whether to verify SSL certificates
+
+    Returns:
+        Tuple of (vm_list, error_message)
+        - On success: (list of VMs, None)
+        - On failure: (None, error message)
+    """
+    client = VCenterClient(server, username, password, verify_ssl)
+
+    try:
+        client.connect()
+        vms = client.fetch_all_vms()
+        return vms, None
+    except vim.fault.InvalidLogin as e:
+        logger.error(f"vCenter authentication failed: {e.msg}")
+        return None, f"Authentication failed: Invalid username or password"
+    except Exception as e:
+        logger.error(f"vCenter connection failed: {e}")
+        return None, f"Connection failed: {str(e)}"
+    finally:
+        client.disconnect()

netbox_vcenter/forms.py

@@ -0,0 +1,77 @@
+"""Forms for NetBox vCenter plugin."""
+
+from django import forms
+from django.conf import settings
+from virtualization.models import Cluster
+
+
+class VCenterConnectForm(forms.Form):
+    """Form for connecting to a vCenter server."""
+
+    server = forms.ChoiceField(
+        label="vCenter Server",
+        help_text="Select the vCenter server to connect to",
+        widget=forms.Select(attrs={"class": "form-select"}),
+    )
+    username = forms.CharField(
+        label="Username",
+        help_text="Enter your username (e.g., domain\\user or user@domain)",
+        widget=forms.TextInput(attrs={"class": "form-control", "placeholder": "domain\\username"}),
+    )
+    password = forms.CharField(
+        label="Password",
+        widget=forms.PasswordInput(attrs={"class": "form-control"}),
+    )
+    verify_ssl = forms.BooleanField(
+        label="Verify SSL Certificate",
+        required=False,
+        initial=False,
+        help_text="Enable for trusted certificates (disable for self-signed)",
+        widget=forms.CheckboxInput(attrs={"class": "form-check-input"}),
+    )
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        # Populate server choices from plugin config
+        config = settings.PLUGINS_CONFIG.get("netbox_vcenter", {})
+        servers = config.get("vcenter_servers", [])
+        self.fields["server"].choices = [(s, s) for s in servers]
+
+
+class VMImportForm(forms.Form):
+    """Form for importing VMs from vCenter to NetBox."""
+
+    cluster = forms.ModelChoiceField(
+        queryset=Cluster.objects.all(),
+        label="Target Cluster",
+        help_text="NetBox cluster to assign the imported VMs to",
+        widget=forms.Select(attrs={"class": "form-select"}),
+    )
+    selected_vms = forms.CharField(
+        widget=forms.HiddenInput(),
+        help_text="JSON list of selected VM names",
+    )
+    vcenter_server = forms.CharField(
+        widget=forms.HiddenInput(),
+        help_text="Source vCenter server",
+    )
+    update_existing = forms.BooleanField(
+        label="Update existing VMs",
+        required=False,
+        initial=False,
+        help_text="Update vCPUs, memory, disk, status, and IP address for VMs that already exist in NetBox",
+        widget=forms.CheckboxInput(attrs={"class": "form-check-input"}),
+    )
+
+    def clean_selected_vms(self):
+        """Parse the selected VMs JSON string."""
+        import json
+
+        data = self.cleaned_data.get("selected_vms", "[]")
+        try:
+            vms = json.loads(data)
+            if not isinstance(vms, list):
+                raise forms.ValidationError("Invalid VM selection format")
+            return vms
+        except json.JSONDecodeError:
+            raise forms.ValidationError("Invalid VM selection data")

netbox_vcenter/navigation.py

@@ -0,0 +1,25 @@
+"""Navigation menu items for NetBox vCenter plugin."""
+
+from netbox.plugins import PluginMenu, PluginMenuItem
+
+menu = PluginMenu(
+    label="vCenter",
+    groups=(
+        (
+            "Virtual Machines",
+            (
+                PluginMenuItem(
+                    link="plugins:netbox_vcenter:dashboard",
+                    link_text="Import Dashboard",
+                    permissions=["virtualization.view_virtualmachine"],
+                ),
+                PluginMenuItem(
+                    link="plugins:netbox_vcenter:compare",
+                    link_text="Compare with NetBox",
+                    permissions=["virtualization.view_virtualmachine"],
+                ),
+            ),
+        ),
+    ),
+    icon_class="mdi mdi-server",
+)

netbox_vcenter/templates/netbox_vcenter/compare.html

@@ -0,0 +1,219 @@
+{% extends 'base/layout.html' %}
+{% load helpers %}
+
+{% block title %}vCenter vs NetBox Comparison{% endblock %}
+
+{% block content %}
+<div class="row mb-4">
+    <div class="col-md-12">
+        <div class="card">
+            <div class="card-header d-flex justify-content-between align-items-center">
+                <h5 class="card-title mb-0">
+                    <i class="mdi mdi-compare"></i> Compare vCenter with NetBox
+                </h5>
+                <div>
+                    <select class="form-select form-select-sm d-inline-block w-auto" id="server-select">
+                        <option value="">Select vCenter...</option>
+                        {% for s in servers %}
+                        <option value="{{ s }}" {% if s == server %}selected{% endif %}>{{ s }}</option>
+                        {% endfor %}
+                    </select>
+                </div>
+            </div>
+            <div class="card-body">
+                {% if not server %}
+                <div class="alert alert-info">
+                    <i class="mdi mdi-information"></i>
+                    Select a vCenter server to compare with NetBox VMs.
+                </div>
+                {% elif not cached_data %}
+                <div class="alert alert-warning">
+                    <i class="mdi mdi-alert"></i>
+                    No cached data for <strong>{{ server }}</strong>.
+                    <a href="{% url 'plugins:netbox_vcenter:dashboard' %}?server={{ server }}">Sync first</a>.
+                </div>
+                {% else %}
+                <!-- Summary Stats -->
+                <div class="row mb-4">
+                    <div class="col-md-3">
+                        <div class="card bg-primary text-white">
+                            <div class="card-body text-center">
+                                <h3 class="mb-0">{{ in_both_count }}</h3>
+                                <small>In Both</small>
+                            </div>
+                        </div>
+                    </div>
+                    <div class="col-md-3">
+                        <div class="card bg-success text-white">
+                            <div class="card-body text-center">
+                                <h3 class="mb-0">{{ only_vcenter_count }}</h3>
+                                <small>Only in vCenter</small>
+                            </div>
+                        </div>
+                    </div>
+                    <div class="col-md-3">
+                        <div class="card bg-secondary text-white">
+                            <div class="card-body text-center">
+                                <h3 class="mb-0">{{ only_netbox_count }}</h3>
+                                <small>Only in NetBox</small>
+                            </div>
+                        </div>
+                    </div>
+                    <div class="col-md-3">
+                        <div class="card bg-danger text-white">
+                            <div class="card-body text-center">
+                                <h3 class="mb-0">{{ diff_count }}</h3>
+                                <small>Spec Differences</small>
+                            </div>
+                        </div>
+                    </div>
+                </div>
+
+                <!-- Only in vCenter (Can Import) -->
+                {% if comparison.only_in_vcenter %}
+                <h5 class="mt-4 mb-3">
+                    <span class="badge bg-success text-white">{{ only_vcenter_count }}</span>
+                    Only in vCenter (Can Import)
+                </h5>
+                <div class="table-responsive mb-4">
+                    <table class="table table-sm table-hover table-striped">
+                        <thead class="table-success">
+                            <tr>
+                                <th>VM Name</th>
+                                <th>Power</th>
+                                <th>vCPUs</th>
+                                <th>Memory</th>
+                                <th>Disk</th>
+                                <th>Cluster</th>
+                            </tr>
+                        </thead>
+                        <tbody>
+                            {% for vm in comparison.only_in_vcenter %}
+                            <tr>
+                                <td><strong>{{ vm.name }}</strong></td>
+                                <td>
+                                    {% if vm.power_state == 'on' %}
+                                    <span class="badge bg-success text-white">ON</span>
+                                    {% else %}
+                                    <span class="badge bg-secondary text-white">OFF</span>
+                                    {% endif %}
+                                </td>
+                                <td>{{ vm.vcpus|default:'-' }}</td>
+                                <td>{{ vm.memory_mb|default:'-' }}</td>
+                                <td>{{ vm.disk_gb|default:'-' }}</td>
+                                <td>{{ vm.cluster|default:'-' }}</td>
+                            </tr>
+                            {% endfor %}
+                        </tbody>
+                    </table>
+                </div>
+                {% endif %}
+
+                <!-- VMs with Differences -->
+                {% if diff_count > 0 %}
+                <div class="d-flex justify-content-between align-items-center mt-4 mb-3">
+                    <h5 class="mb-0">
+                        <span class="badge bg-danger text-white">{{ diff_count }}</span>
+                        VMs with Spec Differences
+                    </h5>
+                    <form method="post" action="{% url 'plugins:netbox_vcenter:sync_differences' %}" class="d-inline">
+                        {% csrf_token %}
+                        <input type="hidden" name="server" value="{{ server }}">
+                        <button type="submit" class="btn btn-sm btn-primary"
+                                onclick="return confirm('Sync {{ diff_count }} VM(s) with spec differences from vCenter to NetBox?');">
+                            <i class="mdi mdi-sync"></i> Sync All Differences
+                        </button>
+                    </form>
+                </div>
+                <div class="table-responsive mb-4">
+                    <table class="table table-sm table-hover table-striped">
+                        <thead class="table-danger">
+                            <tr>
+                                <th>VM Name</th>
+                                <th>Field</th>
+                                <th>vCenter</th>
+                                <th>NetBox</th>
+                            </tr>
+                        </thead>
+                        <tbody>
+                            {% for vm in comparison.in_both %}
+                            {% if vm.has_differences %}
+                            {% if vm.vcenter.vcpus != vm.netbox.vcpus %}
+                            <tr>
+                                <td><strong>{{ vm.name }}</strong></td>
+                                <td>vCPUs</td>
+                                <td>{{ vm.vcenter.vcpus|default:'-' }}</td>
+                                <td>{{ vm.netbox.vcpus|default:'-' }}</td>
+                            </tr>
+                            {% endif %}
+                            {% if vm.vcenter.memory_mb != vm.netbox.memory_mb %}
+                            <tr>
+                                <td><strong>{{ vm.name }}</strong></td>
+                                <td>Memory (MB)</td>
+                                <td>{{ vm.vcenter.memory_mb|default:'-' }}</td>
+                                <td>{{ vm.netbox.memory_mb|default:'-' }}</td>
+                            </tr>
+                            {% endif %}
+                            {% if vm.vcenter.disk_gb != vm.netbox.disk_gb %}
+                            <tr>
+                                <td><strong>{{ vm.name }}</strong></td>
+                                <td>Disk (GB)</td>
+                                <td>{{ vm.vcenter.disk_gb|default:'-' }}</td>
+                                <td>{{ vm.netbox.disk_gb|default:'-' }}</td>
+                            </tr>
+                            {% endif %}
+                            {% endif %}
+                            {% endfor %}
+                        </tbody>
+                    </table>
+                </div>
+                {% endif %}
+
+                <!-- Only in NetBox (Orphaned?) -->
+                {% if comparison.only_in_netbox %}
+                <h5 class="mt-4 mb-3">
+                    <span class="badge bg-secondary text-white">{{ only_netbox_count }}</span>
+                    Only in NetBox (Not in {{ server }})
+                </h5>
+                <div class="table-responsive mb-4">
+                    <table class="table table-sm table-hover table-striped">
+                        <thead class="table-secondary">
+                            <tr>
+                                <th>VM Name</th>
+                                <th>vCPUs</th>
+                                <th>Memory</th>
+                                <th>NetBox Cluster</th>
+                            </tr>
+                        </thead>
+                        <tbody>
+                            {% for vm in comparison.only_in_netbox %}
+                            <tr>
+                                <td><strong>{{ vm.name }}</strong></td>
+                                <td>{{ vm.vcpus|default:'-' }}</td>
+                                <td>{{ vm.memory_mb|default:'-' }}</td>
+                                <td>{{ vm.cluster|default:'-' }}</td>
+                            </tr>
+                            {% endfor %}
+                        </tbody>
+                    </table>
+                </div>
+                <p class="text-muted">
+                    <i class="mdi mdi-information"></i>
+                    These VMs exist in NetBox but were not found in <strong>{{ server }}</strong>.
+                    They may be on a different vCenter or have been deleted.
+                </p>
+                {% endif %}
+                {% endif %}
+            </div>
+        </div>
+    </div>
+</div>
+
+<script>
+document.getElementById('server-select').addEventListener('change', function() {
+    if (this.value) {
+        window.location.href = '?server=' + this.value;
+    }
+});
+</script>
+{% endblock %}