nautobot 2.0.0a2__py3-none-any.whl → 2.0.0b1__py3-none-any.whl

nautobot/extras/plugins/__init__.py

@@ -12,14 +12,10 @@ from django.urls import get_resolver, URLPattern
 
 from nautobot.core.apps import (
     NautobotConfig,
-    NavMenuButton,
-    NavMenuGroup,
-    NavMenuItem,
     NavMenuTab,
     register_menu_items,
     register_homepage_panels,
 )
-from nautobot.core.choices import ButtonColorChoices
 from nautobot.core.utils.deprecation import class_deprecated_in_favor_of
 from nautobot.core.signals import nautobot_database_ready
 from nautobot.extras.choices import BannerClassChoices
@@ -76,11 +72,6 @@ class NautobotAppConfig(NautobotConfig):
     # along with the plugin.
     installed_apps = []
 
-    # Cacheops configuration. Cache all operations by default.
-    caching_config = {
-        "*": {"ops": "all"},
-    }
-
     # Default constance configuration parameters
     constance_config = {}
 
@@ -244,7 +235,6 @@ class NautobotAppConfig(NautobotConfig):
         # TODO(jathan): This is fine for now, but as we expand the functionality
         # of plugins, we'll need to consider something like pydantic or attrs.
         setting_validations = {
-            "caching_config": dict,
             "default_settings": dict,
             "installed_apps": list,
             "middleware": list,
@@ -515,124 +505,17 @@ def register_filter_extensions(filter_extensions, plugin_name):
 #
 
 
-# 2.2 TODO: remove in favor of NavMenuItem
-@class_deprecated_in_favor_of(NavMenuItem)
-class PluginMenuItem:
-    """
-    This class represents a navigation menu item. This constitutes primary link and its text, but also allows for
-    specifying additional link buttons that appear to the right of the item in the van menu.
-
-    Links are specified as Django reverse URL strings.
-    Buttons are each specified as a list of PluginMenuButton instances.
-    """
-
-    permissions = []
-    buttons = []
-
-    def __init__(self, link, link_text, permissions=None, buttons=None):
-        self.link = link
-        self.link_text = link_text
-        if permissions is not None:
-            if not isinstance(permissions, (list, tuple)):
-                raise TypeError("Permissions must be passed as a tuple or list.")
-            self.permissions = permissions
-        if buttons is not None:
-            if not isinstance(buttons, (list, tuple)):
-                raise TypeError("Buttons must be passed as a tuple or list.")
-            self.buttons = buttons
-
-
-# 2.2 TODO: remove in favor of NavMenuButton
-@class_deprecated_in_favor_of(NavMenuButton)
-class PluginMenuButton:
-    """
-    This class represents a button within a PluginMenuItem. Note that button colors should come from
-    ButtonColorChoices.
-    """
-
-    color = ButtonColorChoices.DEFAULT
-    permissions = []
-
-    def __init__(self, link, title, icon_class, color=None, permissions=None):
-        self.link = link
-        self.title = title
-        self.icon_class = icon_class
-        if permissions is not None:
-            if not isinstance(permissions, (list, tuple)):
-                raise TypeError("Permissions must be passed as a tuple or list.")
-            self.permissions = permissions
-        if color is not None:
-            if color not in ButtonColorChoices.values():
-                raise ValueError("Button color must be a choice within ButtonColorChoices.")
-            self.color = color
-
-
 def register_plugin_menu_items(section_name, menu_items):
     """
-    Register a list of PluginMenuItem instances for a given menu section (e.g. plugin name)
+    Register a list of NavMenuTab instances for a given menu section (e.g. plugin name)
     """
-    new_menu_items = []
-    new_menu_item_weight = 100
-
     nav_menu_items = set()
 
-    permissions = set()
-
     for menu_item in menu_items:
-        if isinstance(menu_item, PluginMenuItem):
-            # translate old-style plugin menu definitions into the new nav-menu items and buttons
-
-            new_menu_button_weight = 100
-            new_menu_buttons = []
-            for button in menu_item.buttons:
-                new_menu_buttons.append(
-                    NavMenuButton(
-                        link=button.link,
-                        title=button.title,
-                        icon_class=button.icon_class,
-                        button_class=button.color,
-                        permissions=button.permissions,
-                        weight=new_menu_button_weight,
-                    )
-                )
-                new_menu_button_weight += 100
-
-            new_menu_items.append(
-                NavMenuItem(
-                    link=menu_item.link,
-                    name=menu_item.link_text,
-                    permissions=menu_item.permissions,
-                    weight=new_menu_item_weight,
-                    buttons=new_menu_buttons,
-                )
-            )
-            new_menu_item_weight += 100
-            permissions = permissions.union(menu_item.permissions)
-        elif isinstance(menu_item, NavMenuTab):
+        if isinstance(menu_item, NavMenuTab):
             nav_menu_items.add(menu_item)
         else:
-            raise TypeError("Top level objects need to be an instance of NavMenuTab or PluginMenuItem: {menu_tab}")
-
-    if new_menu_items:
-        # wrap bare item/button list into the default "Plugins" menu tab and appropriate grouping
-        if registry["nav_menu"]["tabs"].get("Plugins"):
-            weight = (
-                registry["nav_menu"]["tabs"]["Plugins"]["groups"][
-                    list(registry["nav_menu"]["tabs"]["Plugins"]["groups"])[-1]
-                ]["weight"]
-                + 100
-            )
-        else:
-            weight = 100
-        nav_menu_items.add(
-            NavMenuTab(
-                name="Plugins",
-                weight=5000,
-                # Permissions cast to tuple to match development pattern.
-                permissions=tuple(permissions),
-                groups=(NavMenuGroup(name=section_name, weight=weight, items=new_menu_items),),
-            ),
-        )
+            raise TypeError(f"Top level objects need to be an instance of NavMenuTab: {menu_item}")
 
     register_menu_items(nav_menu_items)
 
@@ -697,7 +580,6 @@ def register_custom_validators(class_list):
 
 
 def register_override_views(override_views, plugin):
-
     validation_error = (
         "Plugin '{}' tried to override view '{}' but did not contain a valid app name "
         "(e.g. `dcim:device`, `plugins:myplugin:myview`)."

nautobot/extras/plugins/utils.py

@@ -103,9 +103,6 @@ def load_plugin(plugin_name, settings):
         if middleware not in settings.MIDDLEWARE:
             settings.MIDDLEWARE.append(middleware)
 
-    # Update caching configg
-    settings.CACHEOPS.update({f"{plugin_name}.{key}": value for key, value in plugin_config.caching_config.items()})
-
     # Update Constance Config and Constance Fieldset
     if plugin_config.constance_config:
         app_config = {}

nautobot/extras/plugins/validators.py

@@ -1,6 +1,6 @@
 from functools import wraps
 
-from django.contrib.contenttypes.models import ContentType
+from django.apps import apps
 
 from nautobot.extras.plugins import CustomValidator
 from nautobot.extras.registry import registry
@@ -40,6 +40,7 @@ def wrap_model_clean_methods():
     """
     Helper function that wraps plugin model validator registered clean methods for all applicable models
     """
-    for model in ContentType.objects.filter(FeatureQuery("custom_validators").get_query()):
-        model_class = model.model_class()
-        model_class.clean = custom_validator_clean(model_class.clean)
+    for app_label, models in FeatureQuery("custom_validators").as_dict():
+        for model in models:
+            model_class = apps.get_model(app_label=app_label, model_name=model)
+            model_class.clean = custom_validator_clean(model_class.clean)

nautobot/extras/plugins/views.py

@@ -88,7 +88,7 @@ class InstalledPluginDetailView(LoginRequiredMixin, View):
 
 class InstalledPluginsAPIView(NautobotAPIVersionMixin, APIView):
     """
-    API view for listing all installed plugins
+    API view for listing all installed non-core Apps.
     """
 
     permission_classes = [permissions.IsAdminUser]
@@ -99,15 +99,28 @@ class InstalledPluginsAPIView(NautobotAPIVersionMixin, APIView):
 
     @staticmethod
     def _get_plugin_data(plugin_app_config):
+        try:
+            home_url = reverse(plugin_app_config.home_view_name)
+        except NoReverseMatch:
+            home_url = None
+        try:
+            config_url = reverse(plugin_app_config.config_view_name)
+        except NoReverseMatch:
+            config_url = None
+        try:
+            docs_url = reverse(plugin_app_config.docs_view_name)
+        except NoReverseMatch:
+            docs_url = None
         return {
             "name": plugin_app_config.verbose_name,
             "package": plugin_app_config.name,
             "author": plugin_app_config.author,
             "author_email": plugin_app_config.author_email,
             "description": plugin_app_config.description,
-            # 2.0 TODO: Remove verison key/value when bumping to major revision
-            "verison": plugin_app_config.version,
             "version": plugin_app_config.version,
+            "home_url": home_url,
+            "config_url": config_url,
+            "docs_url": docs_url,
         }
 
     @extend_schema(exclude=True)
@@ -142,7 +155,6 @@ class PluginsAPIRootView(NautobotAPIVersionMixin, APIView):
 
     @extend_schema(exclude=True)
     def get(self, request, format=None):  # pylint: disable=redefined-builtin
-
         entries = []
         for plugin in settings.PLUGINS:
             app_config = apps.get_app_config(plugin)

nautobot/extras/querysets.py

@@ -185,18 +185,12 @@ class JobQuerySet(RestrictedQuerySet):
 
     def get_for_class_path(self, class_path):
         try:
-            source, module_name, job_class_name = class_path.split("/")
-            repository_slug = None
-            if source.startswith("git."):
-                repository_slug = source[4:]
-                source = "git"
+            module_name, job_class_name = class_path.rsplit(".", 1)
         except ValueError:  # not a class_path perhaps?
             raise self.model.DoesNotExist()
         return self.get(
-            source=source,
             module_name=module_name,
             job_class_name=job_class_name,
-            git_repository__slug=repository_slug,
         )
 
 

nautobot/extras/registry.py

@@ -51,6 +51,9 @@ class DatasourceContent:
         self.callback = callback
         self.weight = weight
 
+    def __repr__(self):
+        return f"<{self.__class__.__name__}: {self.content_identifier}>"
+
 
 def register_datasource_contents(datasource_contents_list):
     """

nautobot/extras/signals.py

@@ -1,11 +1,9 @@
 import os
 import random
 import shutil
-import uuid
 import logging
 from datetime import timedelta
 
-from cacheops.signals import cache_invalidated, cache_read
 from django.contrib.contenttypes.models import ContentType
 from django.core.exceptions import ValidationError
 from django.db import transaction
@@ -13,8 +11,8 @@ from django.db.models.signals import m2m_changed, pre_delete, pre_save
 from django.dispatch import receiver
 from django.utils import timezone
 from django_prometheus.models import model_deletes, model_inserts, model_updates
-from prometheus_client import Counter
 
+from nautobot.core.celery import app, import_jobs_as_celery_tasks
 from nautobot.core.utils.config import get_settings_or_config
 from nautobot.extras.tasks import delete_custom_field_data, provision_field
 from nautobot.extras.utils import refresh_job_model_from_job_class
@@ -155,30 +153,6 @@ def handle_cf_removed_obj_types(instance, action, pk_set, **kwargs):
 m2m_changed.connect(handle_cf_removed_obj_types, sender=CustomField.content_types.through)
 
 
-#
-# Caching
-#
-
-cacheops_cache_hit = Counter("cacheops_cache_hit", "Number of cache hits")
-cacheops_cache_miss = Counter("cacheops_cache_miss", "Number of cache misses")
-cacheops_cache_invalidated = Counter("cacheops_cache_invalidated", "Number of cache invalidations")
-
-
-def cache_read_collector(sender, func, hit, **kwargs):
-    if hit:
-        cacheops_cache_hit.inc()
-    else:
-        cacheops_cache_miss.inc()
-
-
-def cache_invalidated_collector(sender, obj_dict, **kwargs):
-    cacheops_cache_invalidated.inc()
-
-
-cache_read.connect(cache_read_collector)
-cache_invalidated.connect(cache_invalidated_collector)
-
-
 #
 # Datasources
 #
@@ -195,11 +169,12 @@ def git_repository_pre_delete(instance, **kwargs):
     """
     from nautobot.extras.datasources import refresh_datasource_content
 
+    # FIXME(jathan): In light of jobs overhaul and Git syncs as jobs, we need to rethink this. We
+    # might instead make "delete" another Job class and call it here, but also think about how
+    # worker events will be such as firing the worker event here.
     job_result = JobResult.objects.create(
         name=instance.name,
-        obj_type=ContentType.objects.get_for_model(instance),
         user=None,
-        task_id=uuid.uuid4(),
         status=JobResultStatusChoices.STATUS_STARTED,
     )
 
@@ -210,13 +185,13 @@ def git_repository_pre_delete(instance, **kwargs):
 
     refresh_datasource_content("extras.gitrepository", instance, None, job_result, delete=True)
 
-    if job_result.status not in JobResultStatusChoices.READY_STATES:
-        job_result.set_status(JobResultStatusChoices.STATUS_SUCCESS)
-    job_result.save()
-
-    # TODO(Glenn): In a distributed Nautobot deployment, each Django instance and/or worker instance may have its own clone
+    # In a distributed Nautobot deployment, each Django instance and/or worker instance may have its own clone
     # of this repository; we need some way to ensure that all such clones are deleted.
-    # For now we just delete the one that we have locally and rely on other methods (notably get_jobs())
+    # In the Celery worker case, we can broadcast a control message to all workers to do so:
+    app.control.broadcast("discard_git_repository", repository_slug=instance.slug)
+    # But we don't have an equivalent way to broadcast to any other Django instances.
+    # For now we just delete the one that we have locally and rely on other methods,
+    # such as the import_jobs_as_celery_tasks() signal that runs on server startup,
     # to clean up other clones as they're encountered.
     if os.path.isdir(instance.filesystem_path):
         shutil.rmtree(instance.filesystem_path)
@@ -262,40 +237,31 @@ def refresh_job_models(sender, *, apps, **kwargs):
     """
     Callback for the nautobot_database_ready signal; updates Jobs in the database based on Job source file availability.
     """
+    from nautobot.extras.jobs import Job as JobClass  # avoid circular import
+
     Job = apps.get_model("extras", "Job")
-    GitRepository = apps.get_model("extras", "GitRepository")  # pylint: disable=redefined-outer-name
 
     # To make reverse migrations safe
-    if not hasattr(Job, "job_class_name") or not hasattr(Job, "git_repository"):
+    if not hasattr(Job, "job_class_name"):
         logger.info("Skipping refresh_job_models() as it appears Job model has not yet been migrated to latest.")
         return
 
-    from nautobot.extras.jobs import get_jobs
+    import_jobs_as_celery_tasks(app)
 
-    # TODO(Glenn): eventually this should be inverted so that get_jobs() relies on the database models...
-    job_classes = get_jobs()
     job_models = []
-    for source, modules in job_classes.items():
-        git_repository = None
-        if source.startswith("git."):
-            try:
-                git_repository = GitRepository.objects.get(slug=source[4:])
-            except GitRepository.DoesNotExist:
-                logger.warning('GitRepository "%s" not found?', source[4:])
-            source = "git"
-
-        for module_details in modules.values():
-            for job_class in module_details["jobs"].values():
-                job_model, _ = refresh_job_model_from_job_class(Job, source, job_class, git_repository=git_repository)
-                if job_model is not None:
-                    job_models.append(job_model)
-
-    for job_model in Job.objects.all():
-        if job_model.installed and job_model not in job_models:
+    for task in app.tasks.values():
+        # Skip Celery tasks that aren't Jobs
+        if not isinstance(task, JobClass):
+            continue
+
+        job_model, _ = refresh_job_model_from_job_class(Job, task.__class__)
+        if job_model is not None:
+            job_models.append(job_model)
+
+    for job_model in Job.objects.filter(installed=True):
+        if job_model not in job_models:
             logger.info(
-                "Job %s%s/%s/%s is no longer installed",
-                job_model.source,
-                f"/{job_model.git_repository.slug}" if job_model.git_repository is not None else "",
+                "Job %s/%s is no longer installed",
                 job_model.module_name,
                 job_model.job_class_name,
             )