netbox-vcloud 0.2.0__tar.gz → 0.2.2__tar.gz

{netbox_vcloud-0.2.0 → netbox_vcloud-0.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: netbox-vcloud
-Version: 0.2.0
+Version: 0.2.2
 Summary: NetBox plugin for synchronizing vCloud VMs via ORM
 Author-email: Serhii Zahuba <dev@sss.com>
 Classifier: Development Status :: 3 - Alpha

netbox_vcloud-0.2.2/netbox_vcloud/__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_vcloud"
+        verbose_name = "NetBox vCloud"
+        description = "Synchronize vCloud VMs into NetBox using ORM"
+        version = "0.2.0"
+        author = "Serhii Zahuba"
+        author_email = "dev@cre.com"
+        base_url = "vcloud"
+        required_settings = []
+        default_settings = {}
+
+        def ready(self):
+            super().ready()
+            from . import jobs, template_content
+
+    config = CloudSyncConfig

netbox_vcloud-0.2.2/netbox_vcloud/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.2.2/netbox_vcloud/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.2.2/netbox_vcloud/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.2.2/netbox_vcloud/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.2.2/netbox_vcloud/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.2.2/netbox_vcloud/jobs/__init__.py

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

netbox_vcloud-0.2.2/netbox_vcloud/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.2.2/netbox_vcloud/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.2.2/netbox_vcloud/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_vcloud', '0001_initial'),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name='cloudsyncconfig',
+            name='next_sync',
+            field=models.DateTimeField(blank=True, null=True),
+        ),
+    ]

netbox_vcloud-0.2.2/netbox_vcloud/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_vcloud', '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.2.2/netbox_vcloud/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.2.2/netbox_vcloud/navigation.py

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

netbox_vcloud-0.2.2/netbox_vcloud/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.2.2/netbox_vcloud/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.2.2/netbox_vcloud/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.2.2/netbox_vcloud/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_vcloud.cloudsyncconfig'
+
+    def buttons(self):
+        obj = self.context.get('object')
+        if not obj or obj._meta.label_lower != 'netbox_vcloud.cloudsyncconfig':
+            return ""
+
+
+        url = reverse('plugins:netbox_vcloud: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.2.2/netbox_vcloud/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.2.2/netbox_vcloud/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.2.2/netbox_vcloud/templatetags/__init__.py

@@ -0,0 +1 @@
+

netbox_vcloud-0.2.2/netbox_vcloud/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.2.2/netbox_vcloud/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.2.2/netbox_vcloud/views.py

@@ -0,0 +1,61 @@
+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()
+    template_name = "netbox_vcloud/cloudsyncconfig.html"
+
+    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.2.0 → netbox_vcloud-0.2.2}/netbox_vcloud.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: netbox-vcloud
-Version: 0.2.0
+Version: 0.2.2
 Summary: NetBox plugin for synchronizing vCloud VMs via ORM
 Author-email: Serhii Zahuba <dev@sss.com>
 Classifier: Development Status :: 3 - Alpha

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

@@ -0,0 +1,33 @@
+MANIFEST.in
+README.md
+pyproject.toml
+netbox_vcloud/__init__.py
+netbox_vcloud/admin.py
+netbox_vcloud/forms.py
+netbox_vcloud/models.py
+netbox_vcloud/navigation.py
+netbox_vcloud/sync.py
+netbox_vcloud/sync_utils.py
+netbox_vcloud/tables.py
+netbox_vcloud/template_content.py
+netbox_vcloud/urls.py
+netbox_vcloud/views.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
+netbox_vcloud/api/serializers.py
+netbox_vcloud/api/urls.py
+netbox_vcloud/api/views.py
+netbox_vcloud/jobs/__init__.py
+netbox_vcloud/jobs/cloudsync.py
+netbox_vcloud/migrations/0001_initial.py
+netbox_vcloud/migrations/0002_cloudsyncconfig_next_sync.py
+netbox_vcloud/migrations/0003_cloudsyncconfig_netbox_cluster_and_more.py
+netbox_vcloud/migrations/__init__.py
+netbox_vcloud/templates/netbox_cloudsync/cloudsyncconfig.html
+netbox_vcloud/templates/netbox_cloudsync/cloudsyncconfig_list.html
+netbox_vcloud/templatetags/__init__.py
+netbox_vcloud/templatetags/boolean_icon.py
+test/test_sync_utils.py

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

@@ -0,0 +1 @@
+netbox_vcloud

{netbox_vcloud-0.2.0 → netbox_vcloud-0.2.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "netbox-vcloud"
-version = "0.2.0"
+version = "0.2.2"
 authors = [
     {name = "Serhii Zahuba", email = "dev@sss.com"},
 ]

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

@@ -1,9 +0,0 @@
-MANIFEST.in
-README.md
-pyproject.toml
-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