netbox-vcloud 0.1.2__tar.gz

netbox_vcloud-0.1.2/MANIFEST.in

@@ -0,0 +1,3 @@
+include README.md
+recursive-include netbox_cloudsync/templates *
+recursive-include netbox_cloudsync/migrations *.py

netbox_vcloud-0.1.2/PKG-INFO

@@ -0,0 +1,69 @@
+Metadata-Version: 2.4
+Name: netbox-vcloud
+Version: 0.1.2
+Summary: NetBox plugin for synchronizing vCloud VMs via ORM
+Author-email: Serhii Zahuba <dev@sss.com>
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: System Administrators
+Classifier: Programming Language :: Python :: 3
+Classifier: Framework :: Django
+Classifier: Framework :: Django :: 5.2
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: requests>=2.31
+Provides-Extra: test
+Requires-Dist: pytest>=8.2; extra == "test"
+
+<div align="center">
+
+# NetBox vCloud Plugin
+### _Synchronize vCloud Director VMs into NetBox_
+
+[![GitHub Repo stars](https://img.shields.io/github/stars/SerhiiZahuba/netbox-vcloud-sync-plugin?style=social)](https://github.com/SerhiiZahuba/netbox-vcloud-sync-plugin/stargazers)
+![NetBox version](https://img.shields.io/badge/netbox-4.4.1-blue)
+![Python](https://img.shields.io/badge/python-3.11%2B-yellow)
+![License](https://img.shields.io/github/license/SerhiiZahuba/netbox-vcloud-sync-plugin?color=green)
+
+</div>
+
+---
+
+## Overview
+
+**NetBox vCloud** is a NetBox plugin for synchronizing virtual machines from **vCloud Director** into NetBox.
+
+---
+
+## Installation
+
+```bash
+cd /opt/netbox/
+source /opt/netbox/venv/bin/activate
+pip install netbox-vcloud
+python3 manage.py migrate netbox_cloudsync
+```
+
+## Settings
+
+Add to `configuration.py`:
+
+```python
+PLUGINS = [
+    "netbox_cloudsync",
+]
+```
+
+## Development
+
+Run tests locally:
+
+```bash
+pytest
+```
+
+Publish to PyPI from GitHub Actions by pushing a version tag:
+
+```bash
+git tag v0.1.0
+git push origin v0.1.0
+```

netbox_vcloud-0.1.2/README.md

@@ -0,0 +1,53 @@
+<div align="center">
+
+# NetBox vCloud Plugin
+### _Synchronize vCloud Director VMs into NetBox_
+
+[![GitHub Repo stars](https://img.shields.io/github/stars/SerhiiZahuba/netbox-vcloud-sync-plugin?style=social)](https://github.com/SerhiiZahuba/netbox-vcloud-sync-plugin/stargazers)
+![NetBox version](https://img.shields.io/badge/netbox-4.4.1-blue)
+![Python](https://img.shields.io/badge/python-3.11%2B-yellow)
+![License](https://img.shields.io/github/license/SerhiiZahuba/netbox-vcloud-sync-plugin?color=green)
+
+</div>
+
+---
+
+## Overview
+
+**NetBox vCloud** is a NetBox plugin for synchronizing virtual machines from **vCloud Director** into NetBox.
+
+---
+
+## Installation
+
+```bash
+cd /opt/netbox/
+source /opt/netbox/venv/bin/activate
+pip install netbox-vcloud
+python3 manage.py migrate netbox_cloudsync
+```
+
+## Settings
+
+Add to `configuration.py`:
+
+```python
+PLUGINS = [
+    "netbox_cloudsync",
+]
+```
+
+## Development
+
+Run tests locally:
+
+```bash
+pytest
+```
+
+Publish to PyPI from GitHub Actions by pushing a version tag:
+
+```bash
+git tag v0.1.0
+git push origin v0.1.0
+```

netbox_vcloud-0.1.2/netbox_cloudsync/__init__.py

@@ -0,0 +1,22 @@
+try:
+    from netbox.plugins import PluginConfig
+except ModuleNotFoundError:  # pragma: no cover - allows lightweight tooling/tests
+    PluginConfig = None
+    config = None
+else:
+    class CloudSyncConfig(PluginConfig):
+        name = "netbox_cloudsync"
+        verbose_name = "Cloud Synchronization"
+        description = "Synchronize vCloud VMs into NetBox using ORM"
+        version = "0.1.0"
+        author = "Serhii Zahuba"
+        author_email = "dev@cre.com"
+        base_url = "cloudsync"
+        required_settings = []
+        default_settings = {}
+
+        def ready(self):
+            super().ready()
+            from . import jobs, template_content
+
+    config = CloudSyncConfig

netbox_vcloud-0.1.2/netbox_cloudsync/admin.py

@@ -0,0 +1,37 @@
+from django.contrib import admin
+from .models import CloudSyncConfig
+
+
+@admin.register(CloudSyncConfig)
+class CloudSyncConfigAdmin(admin.ModelAdmin):
+    """Адмін-інтерфейс для таблиці конфігурацій CloudSync"""
+
+    list_display = (
+        "name",
+        "vcloud_url",
+        "vcloud_user",
+        "sync_interval_minutes",
+        "last_sync",
+        "enabled",
+    )
+
+    list_filter = ("enabled",)
+    search_fields = ("name", "vcloud_url", "vcloud_user")
+    ordering = ("name",)
+
+    fieldsets = (
+        (None, {
+            "fields": (
+                "name",
+                "vcloud_url",
+                "vcloud_user",
+                "vcloud_password",
+                "sync_interval_minutes",
+                "enabled",
+            )
+        }),
+        ("Статус", {
+            "fields": ("last_sync",),
+            "classes": ("collapse",),
+        }),
+    )

netbox_vcloud-0.1.2/netbox_cloudsync/api/serializers.py

@@ -0,0 +1,12 @@
+from netbox.api.serializers import NetBoxModelSerializer
+from ..models import CloudSyncConfig
+
+
+class CloudSyncConfigSerializer(NetBoxModelSerializer):
+    class Meta:
+        model = CloudSyncConfig
+        fields = (
+            'id', 'display', 'name', 'vcloud_url',
+            'vcloud_user', 'sync_interval_minutes',
+            'last_sync', 'enabled', 'created', 'last_updated'
+        )

netbox_vcloud-0.1.2/netbox_cloudsync/api/urls.py

@@ -0,0 +1,7 @@
+from netbox.api.routers import NetBoxRouter
+from . import views
+
+router = NetBoxRouter()
+router.register('configs', views.CloudSyncConfigViewSet)
+
+urlpatterns = router.urls

netbox_vcloud-0.1.2/netbox_cloudsync/api/views.py

@@ -0,0 +1,8 @@
+from netbox.api.viewsets import NetBoxModelViewSet
+from ..models import CloudSyncConfig
+from .serializers import CloudSyncConfigSerializer
+
+
+class CloudSyncConfigViewSet(NetBoxModelViewSet):
+    queryset = CloudSyncConfig.objects.all()
+    serializer_class = CloudSyncConfigSerializer

netbox_vcloud-0.1.2/netbox_cloudsync/forms.py

@@ -0,0 +1,20 @@
+from netbox.forms import NetBoxModelForm
+from dcim.models import Site, DeviceRole, Platform
+from virtualization.models import Cluster
+from tenancy.models import Tenant
+from .models import CloudSyncConfig
+
+class CloudSyncConfigForm(NetBoxModelForm):
+    class Meta:
+        model = CloudSyncConfig
+        fields = (
+            'name', 'vcloud_url', 'vcloud_user', 'vcloud_password',
+            'sync_interval_minutes', 'sync_templates', 'sync_poweroff',
+            'netbox_site', 'netbox_cluster', 'netbox_role',
+            'netbox_tenant', 'netbox_platform',
+            'last_sync', 'next_sync', 'enabled'
+        )
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.fields['sync_interval_minutes'].disabled = True

netbox_vcloud-0.1.2/netbox_cloudsync/jobs/__init__.py

@@ -0,0 +1 @@
+from .cloudsync import *

netbox_vcloud-0.1.2/netbox_cloudsync/jobs/cloudsync.py

@@ -0,0 +1,340 @@
+import base64
+import time
+import re
+import requests
+from datetime import timedelta
+from django.utils import timezone
+from netbox.jobs import JobRunner, system_job
+from core.choices import JobIntervalChoices
+from ..models import CloudSyncConfig
+from virtualization.models import VirtualMachine, Cluster, VMInterface
+from tenancy.models import Tenant
+from dcim.models import Site, Platform, DeviceRole
+from ipam.models import IPAddress, VLAN
+
+
+# ==============================================
+# 🧩 Main job: sync vCloud → NetBox
+# ==============================================
+class CloudSyncJob(JobRunner):
+    """Sync vCloud → NetBox (via ORM)"""
+
+    class Meta:
+        name = "Cloud Sync Job"
+        description = "Synchronize vCloud VMs into NetBox using ORM"
+
+    def run(self, *args, **kwargs):
+        user = getattr(self.job, "user", None)
+        started_by = f"👤 Started by {user}" if user else ""
+        self.logger.info(f"=== 🔄 Cloud Sync Job started {started_by} ===")
+
+        config_id = kwargs.get("config_id")
+        configs = (
+            CloudSyncConfig.objects.filter(pk=config_id, enabled=True)
+            if config_id
+            else CloudSyncConfig.objects.filter(enabled=True)
+        )
+        if not configs.exists():
+            self.logger.warning("❗ No active configurations found..")
+            return
+
+        for cfg in configs:
+            try:
+                self.logger.info(f"➡️ Sync '{cfg.name}' ({cfg.vcloud_url}) ...")
+
+                self.sync_config(cfg)
+
+                # 🕓 Update time sync
+                cfg.last_sync = timezone.now()
+                interval = cfg.sync_interval_minutes or 60
+                cfg.next_sync = cfg.last_sync + timedelta(minutes=interval)
+                cfg.save(update_fields=["last_sync", "next_sync"])
+
+                self.logger.info(
+                    f"✅ '{cfg.name}' completed (next_sync={cfg.next_sync})"
+                )
+
+            except Exception as e:
+                self.logger.error(f"⚠️ Error '{cfg.name}': {e}")
+                continue
+
+        self.logger.info("=== ✅ Cloud Sync Job completed ===")
+
+    # ======================================================
+    # 🔧 Sync config — token, page, run sync_vm
+    # ======================================================
+    def sync_config(self, cfg):
+        creds = f"{cfg.vcloud_user}:{cfg.vcloud_password}"
+        creds_b64 = base64.b64encode(creds.encode()).decode()
+
+        token_resp = requests.post(
+            f"{cfg.vcloud_url}/cloudapi/1.0.0/sessions",
+            headers={
+                "Authorization": f"Basic {creds_b64}",
+                "Accept": "application/*;version=38.1",
+            },
+            timeout=15,
+        )
+        if token_resp.status_code != 200:
+            self.logger.warning(f"❌ Token not received for {cfg.name}")
+            return
+
+        vcloud_token = token_resp.headers.get("x-vmware-vcloud-access-token")
+        if not vcloud_token:
+            self.logger.warning(f"❌ Empty token in response from {cfg.name}")
+            return
+
+        self.logger.info(f"✅ Token received for {cfg.name}")
+
+        # --- Get all pages from ВМ
+        all_vms = []
+        page, page_size = 1, 128
+
+        while True:
+            vms_resp = requests.get(
+                f"{cfg.vcloud_url}/api/query?type=vm&page={page}&pageSize={page_size}&format=records",
+                headers={
+                    "Accept": "application/*+json;version=38.1",
+                    "Authorization": f"Bearer {vcloud_token}",
+                },
+                timeout=30,
+            )
+            if vms_resp.status_code != 200:
+                self.logger.error(
+                    f"❌ Failed to get VM (page {page}): HTTP {vms_resp.status_code}"
+                )
+                break
+
+            data = vms_resp.json()
+            records = data.get("record", [])
+            if not records:
+                break
+
+            all_vms.extend(records)
+            self.logger.info(f"📄 Page {page}: {len(records)} VM")
+
+            if len(records) < page_size:
+                break
+            page += 1
+            time.sleep(0.3)
+
+        self.logger.info(f"📦 Total {len(all_vms)} VMs received")
+
+        for vm in all_vms:
+            try:
+                href = vm.get("href")
+                if not href:
+                    continue
+                self.sync_vm(cfg, vm, vcloud_token, href)
+            except Exception as e:
+                self.logger.error(f"⚠️ Error during sync_vm {vm.get('name')}: {e}")
+                continue
+
+    # ======================================================
+    # 🧠 Processing a single VM + interfaces + IP
+    # ======================================================
+    def sync_vm(self, cfg, vm, token, href):
+        try:
+            name = vm["name"]
+            status = vm.get("status", "POWERED_ON")
+            cpu = vm.get("numberOfCpus", 0)
+            ram = vm.get("memoryMB", 0)
+            disk = vm.get("totalStorageAllocatedMb", 0)
+
+            if vm.get("isVAppTemplate") and not cfg.sync_templates:
+                self.logger.info(f"⏭ Skipped template {name}")
+                return
+
+            if status == "POWERED_OFF" and not cfg.sync_poweroff:
+                self.logger.info(f"⏭ Skipped offline VM {name}")
+                return
+
+            # --- Details VM
+            details = requests.get(
+                href,
+                headers={
+                    "Accept": "application/*+json;version=38.1",
+                    "Authorization": f"Bearer {token}",
+                },
+                timeout=20,
+            )
+            if details.status_code != 200:
+                self.logger.warning(f"⚠️ Could not get details for {name}")
+                return
+
+            details_json = details.json()
+            net_sections = [
+                s
+                for s in details_json.get("section", [])
+                if s.get("_type") == "NetworkConnectionSectionType"
+            ]
+
+            site = Site.objects.filter(id=cfg.netbox_site_id).first()
+            cluster = Cluster.objects.filter(id=cfg.netbox_cluster_id).first()
+            role = DeviceRole.objects.filter(id=cfg.netbox_role_id).first()
+            tenant = Tenant.objects.filter(id=cfg.netbox_tenant_id).first()
+            platform = Platform.objects.filter(id=cfg.netbox_platform_id).first()
+
+            vm_obj, created = VirtualMachine.objects.get_or_create(
+                name=name,
+                defaults={
+                    "site": site,
+                    "cluster": cluster,
+                    "role": role,
+                    "tenant": tenant,
+                    "platform": platform,
+                    "vcpus": cpu,
+                    "memory": ram,
+                    "disk": disk,
+                    "status": "active" if status == "POWERED_ON" else "offline",
+                },
+            )
+
+            if not created:
+                vm_obj.vcpus = cpu
+                vm_obj.memory = ram
+                vm_obj.disk = disk
+                vm_obj.status = (
+                    "active" if status.upper() == "POWERED_ON" else "offline"
+                )
+                vm_obj.save()
+                self.logger.info(f"♻️ Update VM: {name}")
+            else:
+                self.logger.info(f"🆕 Create VM: {name}")
+
+            # --- Network interfaces + IPs ---
+            net_data = []
+            if net_sections:
+                connections = net_sections[0].get("networkConnection", [])
+                for conn in connections:
+                    net_data.append({
+                        "network": conn.get("network"),
+                        "ip": conn.get("ipAddress"),
+                        "ext_ip": conn.get("externalIpAddress"),
+                        "mac": conn.get("macAddress"),
+                    })
+            else:
+                if vm.get("networkName") and vm.get("ipAddress"):
+                    net_data.append({
+                        "network": vm.get("networkName"),
+                        "ip": vm.get("ipAddress"),
+                        "ext_ip": None,
+                        "mac": None,
+                    })
+
+            if not net_data:
+                self.logger.info(f"ℹ️ {name} has no network interfaces or IPs")
+                return
+
+            for net in net_data:
+                net_name = net.get("network")
+                ip_addr = (net.get("ip") or "").strip()
+                ext_ip = (net.get("ext_ip") or "").strip()
+                mac = (net.get("mac") or "").strip()
+
+                iface_obj = VMInterface.objects.filter(
+                    virtual_machine=vm_obj,
+                    name=net_name or "eth0",
+                ).first()
+
+                iface_obj, _ = VMInterface.objects.get_or_create(
+                    virtual_machine=vm_obj,
+                    name=net_name or "eth0",
+                )
+
+
+                if mac:
+                    mac = mac.strip().lower()
+                    from dcim.models import MACAddress
+
+                    mac_obj, _ = MACAddress.objects.get_or_create(
+                        mac_address=mac,
+                        defaults={"description": f"Imported via CloudSync ({cfg.name})"},
+                    )
+
+                    # Set mac as primary
+                    if iface_obj.primary_mac_address != mac_obj:
+                        iface_obj.primary_mac_address = mac_obj
+                        iface_obj.save()
+                        self.logger.info(f"🔁 MAC update for {name}: {mac}")
+                    else:
+                        self.logger.debug(f"✅ MAC {mac} is already relevant for {name}")
+                else:
+                    self.logger.debug(f"ℹ️ MAC missing for {name}")
+
+
+                vlan = None
+                if net_name:
+                    try:
+                        vid_match = re.search(r"(\d+)", net_name)
+                        vid = int(vid_match.group(1)) if vid_match else None
+                        vlan_defaults = {
+                            "tenant": tenant,
+                            "status": "active",
+                        }
+                        vlan, _ = VLAN.objects.get_or_create(
+                            site=site,
+                            vid=vid or 0,
+                            defaults={"name": net_name, **vlan_defaults},
+                        )
+                    except Exception as vlan_err:
+                        self.logger.warning(f"⚠️ Skipped VLAN {net_name}: {vlan_err}")
+
+                for addr in [ip_addr, ext_ip]:
+                    if not addr:
+                        continue
+                    if "/" not in addr:
+                        addr = f"{addr}/24"
+                    try:
+                        ip_obj, _ = IPAddress.objects.get_or_create(
+                            address=addr,
+                            defaults={
+                                "tenant": tenant,
+                                "status": "active",
+                                "description": f"Imported via CloudSync ({cfg.name})",
+                            },
+                        )
+                        ip_obj.assigned_object = iface_obj
+                        ip_obj.save()
+                        if not vm_obj.primary_ip4:
+                            vm_obj.primary_ip4 = ip_obj
+                            vm_obj.save()
+                        self.logger.info(f"🌐 IP {addr} → {name}")
+                    except Exception as ip_err:
+                        self.logger.warning(f"⚠️ Skipped IP {addr}: {ip_err}")
+                        continue
+
+        except Exception as e:
+            self.logger.error(f"⚠️ Error sync_vm {vm.get('name')} (network): {e}")
+
+
+# ==============================================================
+# 🕓 Scheduler — autorun CloudSyncJob with sync_interval_minutes
+# ==============================================================
+#@system_job(interval=JobIntervalChoices.INTERVAL_HOURLY)
+@system_job(interval=JobIntervalChoices.INTERVAL_MINUTELY)
+class CloudSyncScheduler(JobRunner):
+    """Scheduler: check configs and run CloudSyncJob by next_sync"""
+
+    class Meta:
+        name = "Cloud Sync Scheduler"
+        description = "Auto-schedules CloudSync jobs based on DB intervals"
+
+    def run(self, *args, **kwargs):
+        now = timezone.now()
+        due_configs = CloudSyncConfig.objects.filter(enabled=True, next_sync__lte=now)
+
+        if not due_configs.exists():
+            self.logger.info("⏳ There are no configs for synchronization at this time.")
+            return
+
+        self.logger.info(f"🕓 Find {due_configs.count()} configs for run.")
+        for cfg in due_configs:
+            try:
+                CloudSyncJob.enqueue(config_id=cfg.id)
+                interval = cfg.sync_interval_minutes or 60
+                cfg.next_sync = now + timedelta(minutes=interval)
+                cfg.save(update_fields=["next_sync"])
+                self.logger.info(f"✅ Run sync: {cfg.name} (next={cfg.next_sync})")
+            except Exception as e:
+                self.logger.error(f"⚠️ Failed  '{cfg.name}' queue: {e}")

netbox_vcloud-0.1.2/netbox_cloudsync/migrations/0001_initial.py

@@ -0,0 +1,40 @@
+# Generated by Django 5.2.6 on 2025-10-06 09:37
+
+import netbox.models.deletion
+import taggit.managers
+import utilities.json
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    initial = True
+
+    dependencies = [
+        ('extras', '0133_make_cf_minmax_decimal'),
+    ]
+
+    operations = [
+        migrations.CreateModel(
+            name='CloudSyncConfig',
+            fields=[
+                ('id', models.BigAutoField(auto_created=True, primary_key=True, serialize=False)),
+                ('created', models.DateTimeField(auto_now_add=True, null=True)),
+                ('last_updated', models.DateTimeField(auto_now=True, null=True)),
+                ('custom_field_data', models.JSONField(blank=True, default=dict, encoder=utilities.json.CustomFieldJSONEncoder)),
+                ('name', models.CharField(default='Default', max_length=100)),
+                ('vcloud_url', models.URLField()),
+                ('vcloud_user', models.CharField(max_length=200)),
+                ('vcloud_password', models.CharField(max_length=200)),
+                ('sync_interval_minutes', models.PositiveIntegerField(default=60)),
+                ('last_sync', models.DateTimeField(blank=True, null=True)),
+                ('enabled', models.BooleanField(default=True)),
+                ('tags', taggit.managers.TaggableManager(through='extras.TaggedItem', to='extras.Tag')),
+            ],
+            options={
+                'verbose_name': 'Cloud Sync Config',
+                'verbose_name_plural': 'Cloud Sync Configs',
+            },
+            bases=(netbox.models.deletion.DeleteMixin, models.Model),
+        ),
+    ]

netbox_vcloud-0.1.2/netbox_cloudsync/migrations/0002_cloudsyncconfig_next_sync.py

@@ -0,0 +1,18 @@
+# Generated by Django 5.2.6 on 2025-10-06 11:11
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('netbox_cloudsync', '0001_initial'),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name='cloudsyncconfig',
+            name='next_sync',
+            field=models.DateTimeField(blank=True, null=True),
+        ),
+    ]

netbox_vcloud-0.1.2/netbox_cloudsync/migrations/0003_cloudsyncconfig_netbox_cluster_and_more.py

@@ -0,0 +1,52 @@
+# Generated by Django 5.2.6 on 2025-10-06 11:55
+
+import django.db.models.deletion
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('dcim', '0215_rackreservation_status'),
+        ('netbox_cloudsync', '0002_cloudsyncconfig_next_sync'),
+        ('tenancy', '0020_remove_contactgroupmembership'),
+        ('virtualization', '0048_populate_mac_addresses'),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name='cloudsyncconfig',
+            name='netbox_cluster',
+            field=models.ForeignKey(blank=True, null=True, on_delete=django.db.models.deletion.SET_NULL, to='virtualization.cluster'),
+        ),
+        migrations.AddField(
+            model_name='cloudsyncconfig',
+            name='netbox_platform',
+            field=models.ForeignKey(blank=True, null=True, on_delete=django.db.models.deletion.SET_NULL, to='dcim.platform'),
+        ),
+        migrations.AddField(
+            model_name='cloudsyncconfig',
+            name='netbox_role',
+            field=models.ForeignKey(blank=True, null=True, on_delete=django.db.models.deletion.SET_NULL, to='dcim.devicerole'),
+        ),
+        migrations.AddField(
+            model_name='cloudsyncconfig',
+            name='netbox_site',
+            field=models.ForeignKey(blank=True, null=True, on_delete=django.db.models.deletion.SET_NULL, to='dcim.site'),
+        ),
+        migrations.AddField(
+            model_name='cloudsyncconfig',
+            name='netbox_tenant',
+            field=models.ForeignKey(blank=True, null=True, on_delete=django.db.models.deletion.SET_NULL, to='tenancy.tenant'),
+        ),
+        migrations.AddField(
+            model_name='cloudsyncconfig',
+            name='sync_poweroff',
+            field=models.BooleanField(default=False),
+        ),
+        migrations.AddField(
+            model_name='cloudsyncconfig',
+            name='sync_templates',
+            field=models.BooleanField(default=False),
+        ),
+    ]

netbox_vcloud-0.1.2/netbox_cloudsync/migrations/__init__.py

@@ -0,0 +1 @@
+

netbox_vcloud-0.1.2/netbox_cloudsync/models.py

@@ -0,0 +1,47 @@
+from django.db import models
+from datetime import timedelta
+from django.utils import timezone
+from netbox.models import NetBoxModel
+from dcim.models import Site, DeviceRole, Platform
+from virtualization.models import Cluster
+from tenancy.models import Tenant
+
+
+class CloudSyncConfig(NetBoxModel):
+    """Конфігурація синхронізації з vCloud"""
+    name = models.CharField(max_length=100, default="Default")
+
+    # vCloud credentials
+    vcloud_url = models.URLField()
+    vcloud_user = models.CharField(max_length=200)
+    vcloud_password = models.CharField(max_length=200)
+
+    # Основні налаштування
+    sync_interval_minutes = models.PositiveIntegerField(default=60)
+    last_sync = models.DateTimeField(null=True, blank=True)
+    next_sync = models.DateTimeField(null=True, blank=True)
+    enabled = models.BooleanField(default=True)
+
+    # Нові поля для параметрів синхронізації
+    sync_templates = models.BooleanField(default=False)
+    sync_poweroff = models.BooleanField(default=False)
+
+    netbox_site = models.ForeignKey(Site, on_delete=models.SET_NULL, null=True, blank=True)
+    netbox_cluster = models.ForeignKey(Cluster, on_delete=models.SET_NULL, null=True, blank=True)
+    netbox_role = models.ForeignKey(DeviceRole, on_delete=models.SET_NULL, null=True, blank=True)
+    netbox_tenant = models.ForeignKey(Tenant, on_delete=models.SET_NULL, null=True, blank=True)
+    netbox_platform = models.ForeignKey(Platform, on_delete=models.SET_NULL, null=True, blank=True)
+
+    class Meta:
+        verbose_name = "Cloud Sync Config"
+        verbose_name_plural = "Cloud Sync Configs"
+
+    def __str__(self):
+        return f"{self.name}"
+
+    def save(self, *args, **kwargs):
+        if self.last_sync and self.sync_interval_minutes:
+            self.next_sync = self.last_sync + timedelta(minutes=self.sync_interval_minutes)
+        elif not self.next_sync:
+            self.next_sync = timezone.now() + timedelta(minutes=self.sync_interval_minutes)
+        super().save(*args, **kwargs)

netbox_vcloud-0.1.2/netbox_cloudsync/navigation.py

@@ -0,0 +1,15 @@
+from netbox.plugins import PluginMenuItem, PluginMenuButton
+
+menu_items = (
+    PluginMenuItem(
+        link='plugins:netbox_cloudsync:cloudsyncconfig_list',
+        link_text='Cloud Sync Configs',
+        buttons=(
+            PluginMenuButton(
+                link='plugins:netbox_cloudsync:cloudsyncconfig_add',
+                title='Add Config',
+                icon_class='mdi mdi-plus-thick',
+            ),
+        ),
+    ),
+)

netbox_vcloud-0.1.2/netbox_cloudsync/sync.py

@@ -0,0 +1,102 @@
+import requests
+from django.utils import timezone
+from virtualization.models import VirtualMachine, Cluster, VMInterface
+from tenancy.models import Tenant
+from dcim.models import Site, DeviceRole
+from ipam.models import IPAddress
+
+from .sync_utils import (
+    build_basic_auth_header,
+    extract_primary_connection,
+    normalize_vm_status,
+    should_sync_vm,
+)
+
+REQUEST_TIMEOUT = 30
+
+
+def run_sync(cfg):
+    headers = {
+        "Authorization": build_basic_auth_header(cfg.vcloud_user, cfg.vcloud_password),
+        "Accept": "application/*;version=38.1",
+    }
+
+    response = requests.post(
+        f"{cfg.vcloud_url}/cloudapi/1.0.0/sessions",
+        headers=headers,
+        timeout=REQUEST_TIMEOUT,
+    )
+    response.raise_for_status()
+
+    token = response.headers.get("X-VMWARE-VCLOUD-ACCESS-TOKEN")
+    if not token:
+        raise RuntimeError("vCloud auth failed: missing access token")
+
+    headers = {
+        "Authorization": f"Bearer {token}",
+        "Accept": "application/*+json;version=38.1",
+    }
+
+    vms_response = requests.get(
+        f"{cfg.vcloud_url}/api/query?type=vm&page=1&pageSize=100&format=records",
+        headers=headers,
+        timeout=REQUEST_TIMEOUT,
+    )
+    vms_response.raise_for_status()
+
+    vms = vms_response.json().get("record", [])
+    if isinstance(vms, dict):
+        vms = [vms]
+
+    cluster = cfg.netbox_cluster or Cluster.objects.first()
+    site = cfg.netbox_site or Site.objects.first()
+    role = cfg.netbox_role or DeviceRole.objects.first()
+    tenant = cfg.netbox_tenant or Tenant.objects.first()
+
+    for vm in vms:
+        if not should_sync_vm(vm, cfg):
+            continue
+
+        name = vm.get("name")
+        href = vm.get("href")
+        if not name or not href:
+            continue
+
+        details_response = requests.get(href, headers=headers, timeout=REQUEST_TIMEOUT)
+        details_response.raise_for_status()
+
+        ip, mac = extract_primary_connection(details_response.json())
+
+        vm_obj, _ = VirtualMachine.objects.update_or_create(
+            name=name,
+            defaults={
+                "status": normalize_vm_status(vm.get("status", "POWERED_ON")),
+                "vcpus": vm.get("numberOfCpus", 0),
+                "memory": vm.get("memoryMB", 0),
+                "disk": vm.get("totalStorageAllocatedMb", 0),
+                "cluster": cluster,
+                "site": site,
+                "tenant": tenant,
+                "role": role,
+                "comments": f"Synced {timezone.now().strftime('%F %T')}",
+            },
+        )
+
+        iface_defaults = {"enabled": True}
+        if mac:
+            iface_defaults["mac_address"] = mac
+
+        iface, _ = VMInterface.objects.get_or_create(
+            virtual_machine=vm_obj,
+            name="eth0",
+            defaults=iface_defaults,
+        )
+
+        if ip:
+            ip_obj, _ = IPAddress.objects.get_or_create(address=f"{ip}/24")
+            ip_obj.assigned_object = iface
+            ip_obj.status = "active"
+            ip_obj.save()
+
+    cfg.last_sync = timezone.now()
+    cfg.save()

netbox_vcloud-0.1.2/netbox_cloudsync/sync_utils.py

@@ -0,0 +1,37 @@
+import base64
+
+
+def build_basic_auth_header(username, password):
+    token = base64.b64encode(f"{username}:{password}".encode()).decode()
+    return f"Basic {token}"
+
+
+def extract_primary_connection(details):
+    for section in details.get("section", []):
+        if section.get("_type") != "NetworkConnectionSectionType":
+            continue
+
+        connections = section.get("networkConnection") or []
+        if not connections:
+            return None, None
+
+        connection = connections[0]
+        return connection.get("ipAddress"), connection.get("macAddress")
+
+    return None, None
+
+
+def should_sync_vm(vm, cfg):
+    status = (vm.get("status") or "").upper()
+    if not cfg.sync_poweroff and status != "POWERED_ON":
+        return False
+
+    is_template = vm.get("isVAppTemplate") in (True, "true", "True")
+    if is_template and not cfg.sync_templates:
+        return False
+
+    return True
+
+
+def normalize_vm_status(status):
+    return "active" if (status or "").upper() == "POWERED_ON" else "offline"

netbox_vcloud-0.1.2/netbox_cloudsync/tables.py

@@ -0,0 +1,18 @@
+import django_tables2 as tables
+from netbox.tables import NetBoxTable
+from .models import CloudSyncConfig
+
+
+class CloudSyncConfigTable(NetBoxTable):
+    name = tables.Column(linkify=True)
+
+    class Meta(NetBoxTable.Meta):
+        model = CloudSyncConfig
+        fields = (
+            'pk', 'name', 'vcloud_url', 'netbox_site', 'netbox_cluster',
+            'sync_interval_minutes', 'sync_templates', 'sync_poweroff',
+            'next_sync', 'enabled'
+        )
+        default_columns = (
+            'name', 'netbox_site', 'netbox_cluster', 'next_sync', 'enabled'
+        )

netbox_vcloud-0.1.2/netbox_cloudsync/template_content.py

@@ -0,0 +1,22 @@
+from netbox.plugins import PluginTemplateExtension
+from django.urls import reverse
+from django.utils.html import format_html
+
+
+class CloudSyncConfigButtons(PluginTemplateExtension):
+    model = 'netbox_cloudsync.cloudsyncconfig'
+
+    def buttons(self):
+        obj = self.context.get('object')
+        if not obj or obj._meta.label_lower != 'netbox_cloudsync.cloudsyncconfig':
+            return ""
+
+
+        url = reverse('plugins:netbox_cloudsync:run_sync_now', args=[obj.pk])
+        return format_html(
+            f'<a href="{url}" class="btn btn-sm btn-primary">'
+            f'<i class="mdi mdi-sync"></i> Run Sync Now</a>'
+        )
+
+
+template_extensions = [CloudSyncConfigButtons]

netbox_vcloud-0.1.2/netbox_cloudsync/templates/netbox_cloudsync/cloudsyncconfig.html

@@ -0,0 +1,32 @@
+{% extends 'generic/object.html' %}
+{% load boolean_icon %}
+
+{% block content %}
+<div class="row">
+    <div class="col-md-8">
+        <div class="card">
+            <h5 class="card-header">Cloud Sync Configuration</h5>
+            <div class="card-body">
+                <table class="table table-hover attr-table">
+                    <tr><th>Name</th><td>{{ object.name }}</td></tr>
+                    <tr><th>vCloud URL</th><td>{{ object.vcloud_url }}</td></tr>
+                    <tr><th>User</th><td>{{ object.vcloud_user }}</td></tr>
+                    <tr><th>Interval (min)</th><td>{{ object.sync_interval_minutes }}</td></tr>
+                    <tr><th>Sync Templates</th><td>{{ object.sync_templates|boolean_icon|safe }}</td></tr>
+                    <tr><th>Sync Powered Off</th><td>{{ object.sync_poweroff|boolean_icon|safe }}</td></tr>
+
+                    <tr><th>Site</th><td>{{ object.netbox_site }}</td></tr>
+                    <tr><th>Cluster</th><td>{{ object.netbox_cluster }}</td></tr>
+                    <tr><th>Role</th><td>{{ object.netbox_role }}</td></tr>
+                    <tr><th>Tenant</th><td>{{ object.netbox_tenant }}</td></tr>
+                    <tr><th>Platform</th><td>{{ object.netbox_platform }}</td></tr>
+
+                    <tr><th>Last Sync</th><td>{{ object.last_sync|date:"Y-m-d H:i:s" }}</td></tr>
+                    <tr><th>Next Sync</th><td>{{ object.next_sync|date:"Y-m-d H:i:s" }}</td></tr>
+                    <tr><th>Enabled</th><td>{{ object.enabled|boolean_icon|safe }}</td></tr>
+                </table>
+            </div>
+        </div>
+    </div>
+</div>
+{% endblock %}

netbox_vcloud-0.1.2/netbox_cloudsync/templates/netbox_cloudsync/cloudsyncconfig_list.html

@@ -0,0 +1,5 @@
+{% extends 'generic/object_list.html' %}
+{% load render_table from django_tables2 %}
+{% block content %}
+{% render_table table %}
+{% endblock %}

netbox_vcloud-0.1.2/netbox_cloudsync/templatetags/__init__.py

@@ -0,0 +1 @@
+

netbox_vcloud-0.1.2/netbox_cloudsync/templatetags/boolean_icon.py

@@ -0,0 +1,10 @@
+from django import template
+register = template.Library()
+
+@register.filter()
+def boolean_icon(value):
+
+    if value:
+        return '<span class="text-success"><i class="mdi mdi-check-bold"></i></span>'
+    else:
+        return '<span class="text-danger"><i class="mdi mdi-close-thick"></i></span>'

netbox_vcloud-0.1.2/netbox_cloudsync/urls.py

@@ -0,0 +1,16 @@
+from netbox.plugins import PluginTemplateExtension
+from netbox.views.generic import ObjectChangeLogView
+from .models import CloudSyncConfig
+from django.urls import path
+from . import views
+
+urlpatterns = [
+    path('', views.CloudSyncConfigListView.as_view(), name='cloudsyncconfig_list'),
+    path('add/', views.CloudSyncConfigEditView.as_view(), name='cloudsyncconfig_add'),
+    path('<int:pk>/', views.CloudSyncConfigView.as_view(), name='cloudsyncconfig'),
+    path('<int:pk>/edit/', views.CloudSyncConfigEditView.as_view(), name='cloudsyncconfig_edit'),
+    path('<int:pk>/delete/', views.CloudSyncConfigDeleteView.as_view(), name='cloudsyncconfig_delete'),
+    path('<int:pk>/changelog/', views.CloudSyncConfigChangeLogView.as_view(),
+             name='cloudsyncconfig_changelog'),
+    path('<int:pk>/run/', views.RunSyncNowView.as_view(), name='run_sync_now'),
+]

netbox_vcloud-0.1.2/netbox_cloudsync/views.py

@@ -0,0 +1,60 @@
+from netbox.views import generic
+from netbox.views.generic import ObjectChangeLogView
+from django.contrib import messages
+from django.shortcuts import redirect, get_object_or_404
+from django.views import View
+from .models import CloudSyncConfig
+from .tables import CloudSyncConfigTable
+from .forms import CloudSyncConfigForm
+from .jobs.cloudsync import CloudSyncJob
+from django.urls import reverse
+
+
+class CloudSyncConfigListView(generic.ObjectListView):
+    queryset = CloudSyncConfig.objects.all()
+    table = CloudSyncConfigTable
+
+    def get_queryset(self, request):
+        return CloudSyncConfig.objects.restrict(request.user, 'view')
+
+
+class CloudSyncConfigView(generic.ObjectView):
+    queryset = CloudSyncConfig.objects.all()
+
+    def get_queryset(self, request):
+        return CloudSyncConfig.objects.restrict(request.user, 'view')
+
+
+class CloudSyncConfigEditView(generic.ObjectEditView):
+    queryset = CloudSyncConfig.objects.all()
+    form = CloudSyncConfigForm
+
+    def get_queryset(self, request):
+        return CloudSyncConfig.objects.restrict(request.user, 'edit')
+
+
+class CloudSyncConfigDeleteView(generic.ObjectDeleteView):
+    queryset = CloudSyncConfig.objects.all()
+
+    def get_queryset(self, request):
+        return CloudSyncConfig.objects.restrict(request.user, 'delete')
+
+
+class CloudSyncConfigChangeLogView(ObjectChangeLogView):
+    queryset = CloudSyncConfig.objects.all()
+
+    def get(self, request, *args, **kwargs):
+        return super().get(request, model=CloudSyncConfig, *args, **kwargs)
+
+
+class RunSyncNowView(View):
+    """Manual run CloudSyncJob for CloudSyncConfig."""
+
+    def get(self, request, pk):
+        cfg = get_object_or_404(CloudSyncConfig, pk=pk)
+        job = CloudSyncJob.enqueue(config_id=cfg.id)
+        messages.success(request, f"✅ Sync '{cfg.name}' run in back.")
+        try:
+            return redirect(reverse("core:job", args=[job.id]))
+        except Exception:
+            return redirect(f"/core/jobs/{job.id}/")

netbox_vcloud-0.1.2/netbox_vcloud.egg-info/PKG-INFO

@@ -0,0 +1,69 @@
+Metadata-Version: 2.4
+Name: netbox-vcloud
+Version: 0.1.2
+Summary: NetBox plugin for synchronizing vCloud VMs via ORM
+Author-email: Serhii Zahuba <dev@sss.com>
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: System Administrators
+Classifier: Programming Language :: Python :: 3
+Classifier: Framework :: Django
+Classifier: Framework :: Django :: 5.2
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: requests>=2.31
+Provides-Extra: test
+Requires-Dist: pytest>=8.2; extra == "test"
+
+<div align="center">
+
+# NetBox vCloud Plugin
+### _Synchronize vCloud Director VMs into NetBox_
+
+[![GitHub Repo stars](https://img.shields.io/github/stars/SerhiiZahuba/netbox-vcloud-sync-plugin?style=social)](https://github.com/SerhiiZahuba/netbox-vcloud-sync-plugin/stargazers)
+![NetBox version](https://img.shields.io/badge/netbox-4.4.1-blue)
+![Python](https://img.shields.io/badge/python-3.11%2B-yellow)
+![License](https://img.shields.io/github/license/SerhiiZahuba/netbox-vcloud-sync-plugin?color=green)
+
+</div>
+
+---
+
+## Overview
+
+**NetBox vCloud** is a NetBox plugin for synchronizing virtual machines from **vCloud Director** into NetBox.
+
+---
+
+## Installation
+
+```bash
+cd /opt/netbox/
+source /opt/netbox/venv/bin/activate
+pip install netbox-vcloud
+python3 manage.py migrate netbox_cloudsync
+```
+
+## Settings
+
+Add to `configuration.py`:
+
+```python
+PLUGINS = [
+    "netbox_cloudsync",
+]
+```
+
+## Development
+
+Run tests locally:
+
+```bash
+pytest
+```
+
+Publish to PyPI from GitHub Actions by pushing a version tag:
+
+```bash
+git tag v0.1.0
+git push origin v0.1.0
+```

netbox_vcloud-0.1.2/netbox_vcloud.egg-info/SOURCES.txt

@@ -0,0 +1,33 @@
+MANIFEST.in
+README.md
+pyproject.toml
+netbox_cloudsync/__init__.py
+netbox_cloudsync/admin.py
+netbox_cloudsync/forms.py
+netbox_cloudsync/models.py
+netbox_cloudsync/navigation.py
+netbox_cloudsync/sync.py
+netbox_cloudsync/sync_utils.py
+netbox_cloudsync/tables.py
+netbox_cloudsync/template_content.py
+netbox_cloudsync/urls.py
+netbox_cloudsync/views.py
+netbox_cloudsync/api/serializers.py
+netbox_cloudsync/api/urls.py
+netbox_cloudsync/api/views.py
+netbox_cloudsync/jobs/__init__.py
+netbox_cloudsync/jobs/cloudsync.py
+netbox_cloudsync/migrations/0001_initial.py
+netbox_cloudsync/migrations/0002_cloudsyncconfig_next_sync.py
+netbox_cloudsync/migrations/0003_cloudsyncconfig_netbox_cluster_and_more.py
+netbox_cloudsync/migrations/__init__.py
+netbox_cloudsync/templates/netbox_cloudsync/cloudsyncconfig.html
+netbox_cloudsync/templates/netbox_cloudsync/cloudsyncconfig_list.html
+netbox_cloudsync/templatetags/__init__.py
+netbox_cloudsync/templatetags/boolean_icon.py
+netbox_vcloud.egg-info/PKG-INFO
+netbox_vcloud.egg-info/SOURCES.txt
+netbox_vcloud.egg-info/dependency_links.txt
+netbox_vcloud.egg-info/requires.txt
+netbox_vcloud.egg-info/top_level.txt
+test/test_sync_utils.py

netbox_vcloud-0.1.2/netbox_vcloud.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

netbox_vcloud-0.1.2/netbox_vcloud.egg-info/requires.txt

@@ -0,0 +1,4 @@
+requests>=2.31
+
+[test]
+pytest>=8.2

netbox_vcloud-0.1.2/netbox_vcloud.egg-info/top_level.txt

@@ -0,0 +1 @@
+netbox_cloudsync

netbox_vcloud-0.1.2/pyproject.toml

@@ -0,0 +1,36 @@
+[build-system]
+requires = ["setuptools>=68"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "netbox-vcloud"
+version = "0.1.2"
+authors = [
+    {name = "Serhii Zahuba", email = "dev@sss.com"},
+]
+description = "NetBox plugin for synchronizing vCloud VMs via ORM"
+readme = "README.md"
+requires-python = ">=3.10"
+
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: System Administrators",
+    "Programming Language :: Python :: 3",
+    "Framework :: Django",
+    "Framework :: Django :: 5.2",
+]
+
+dependencies = ["requests>=2.31"]
+
+[project.optional-dependencies]
+test = ["pytest>=8.2"]
+
+[tool.setuptools]
+include-package-data = true
+
+[tool.setuptools.packages.find]
+where = ["."]
+include = ["netbox_cloudsync*"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]

netbox_vcloud-0.1.2/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

netbox_vcloud-0.1.2/test/test_sync_utils.py

@@ -0,0 +1,47 @@
+from types import SimpleNamespace
+
+from netbox_cloudsync.sync_utils import (
+    build_basic_auth_header,
+    extract_primary_connection,
+    normalize_vm_status,
+    should_sync_vm,
+)
+
+
+def test_build_basic_auth_header_encodes_credentials():
+    assert build_basic_auth_header("user", "pass") == "Basic dXNlcjpwYXNz"
+
+
+def test_extract_primary_connection_returns_first_network_values():
+    ip, mac = extract_primary_connection(
+        {
+            "section": [
+                {
+                    "_type": "NetworkConnectionSectionType",
+                    "networkConnection": [
+                        {"ipAddress": "10.0.0.5", "macAddress": "00:11:22:33:44:55"}
+                    ],
+                }
+            ]
+        }
+    )
+
+    assert ip == "10.0.0.5"
+    assert mac == "00:11:22:33:44:55"
+
+
+def test_extract_primary_connection_returns_empty_values_when_missing():
+    assert extract_primary_connection({"section": []}) == (None, None)
+
+
+def test_should_sync_vm_respects_power_and_template_flags():
+    cfg = SimpleNamespace(sync_poweroff=False, sync_templates=False)
+
+    assert should_sync_vm({"status": "POWERED_ON"}, cfg) is True
+    assert should_sync_vm({"status": "POWERED_OFF"}, cfg) is False
+    assert should_sync_vm({"status": "POWERED_ON", "isVAppTemplate": True}, cfg) is False
+
+
+def test_normalize_vm_status_maps_power_state():
+    assert normalize_vm_status("POWERED_ON") == "active"
+    assert normalize_vm_status("POWERED_OFF") == "offline"