nautobot 3.0.3__py3-none-any.whl → 3.0.4__py3-none-any.whl

nautobot/extras/signals.py

@@ -8,6 +8,7 @@ import uuid
 
 from db_file_storage.model_utils import delete_file
 from db_file_storage.storage import DatabaseFileStorage
+from django.conf import settings
 from django.contrib.contenttypes.models import ContentType
 from django.core.cache import cache
 from django.core.exceptions import ValidationError
@@ -19,6 +20,7 @@ from django.utils import timezone
 from django_prometheus.models import model_deletes, model_inserts, model_updates
 import redis.exceptions
 
+from nautobot.core.branching import BranchContext
 from nautobot.core.celery import app, import_jobs
 from nautobot.core.models import BaseModel
 from nautobot.core.utils.cache import construct_cache_key
@@ -214,6 +216,29 @@ def invalidate_gitrepository_provided_contents_cache(sender, **kwargs):
         cache.delete_pattern(f"{cache_key}(*)")
 
 
+def _object_change_branch_name(instance):
+    """
+    Get the version-control branch name (if any) that needs to be switched to for ObjectChanges on a given instance.
+    """
+    if "nautobot_version_control" not in settings.PLUGINS:
+        return None
+
+    # When modifying non-version-controlled models, which only get committed to DOLT_DEFAULT_BRANCH,
+    # we need to ensure that the corresponding ObjectChange also is created there, even if we're otherwise working
+    # in a non-default branch at the moment. Failing to do so would result in a Dolt error on transaction commit:
+    # "Cannot commit changes on more than one branch / database"
+    from nautobot_version_control.constants import DOLT_DEFAULT_BRANCH  # pylint: disable=import-error
+    from nautobot_version_control.utils import (  # pylint: disable=import-error
+        active_branch,
+        is_version_controlled_model,
+    )
+
+    if is_version_controlled_model(instance.__class__) or active_branch() == DOLT_DEFAULT_BRANCH:
+        return None  # no need to switch branches
+
+    return DOLT_DEFAULT_BRANCH  # need to switch temporarily to the default `main` branch for this record
+
+
 @receiver(post_save)
 @receiver(m2m_changed)
 def _handle_changed_object(sender, instance, raw=False, **kwargs):
@@ -242,60 +267,63 @@ def _handle_changed_object(sender, instance, raw=False, **kwargs):
 
     # Record an ObjectChange if applicable
     if hasattr(instance, "to_objectchange"):
+        branch_name = _object_change_branch_name(instance)
         user = change_context.get_user(instance)
-        # save a copy of this instance's field cache so it can be restored after serialization
-        # to prevent unexpected behavior when chaining multiple signal handlers
-        original_cache = instance._state.fields_cache.copy()
-
-        changed_object_type = ContentType.objects.get_for_model(instance)
-        changed_object_id = instance.id
 
-        # Generate a unique identifier for this change to stash in the change context
-        # This is used for deferred change logging and for looking up related changes without querying the database
-        unique_object_change_id = None
-        if user is not None:
-            unique_object_change_id = f"{changed_object_type.pk}__{changed_object_id}__{user.pk}"
-        else:
-            unique_object_change_id = f"{changed_object_type.pk}__{changed_object_id}"
-
-        # If a change already exists for this change_id, user, and object, update it instead of creating a new one.
-        # If the object was deleted then recreated with the same pk (don't do this), change the action to update.
-        if unique_object_change_id in change_context.deferred_object_changes:
-            related_changes = ObjectChange.objects.filter(
-                changed_object_type=changed_object_type,
-                changed_object_id=changed_object_id,
-                user=user,
-                request_id=change_context.change_id,
-            )
-
-            # Skip the database check when deferring object changes
-            if not change_context.defer_object_changes and related_changes.exists():
-                objectchange = instance.to_objectchange(action)
-                if objectchange is not None:
-                    most_recent_change = related_changes.order_by("-time").first()
-                    if most_recent_change.action == ObjectChangeActionChoices.ACTION_DELETE:
-                        most_recent_change.action = ObjectChangeActionChoices.ACTION_UPDATE
-                    most_recent_change.object_data = objectchange.object_data
-                    most_recent_change.object_data_v2 = objectchange.object_data_v2
-                    most_recent_change.save()
+        with BranchContext(branch_name=branch_name, user=user, autocommit=False):
+            # save a copy of this instance's field cache so it can be restored after serialization
+            # to prevent unexpected behavior when chaining multiple signal handlers
+            original_cache = instance._state.fields_cache.copy()
+
+            changed_object_type = ContentType.objects.get_for_model(instance)
+            changed_object_id = instance.id
+
+            # Generate a unique identifier for this change to stash in the change context
+            # This is used for deferred change logging and for looking up related changes without querying the database
+            unique_object_change_id = None
+            if user is not None:
+                unique_object_change_id = f"{changed_object_type.pk}__{changed_object_id}__{user.pk}"
+            else:
+                unique_object_change_id = f"{changed_object_type.pk}__{changed_object_id}"
+
+            # If a change already exists for this change_id, user, and object, update it instead of creating a new one.
+            # If the object was deleted then recreated with the same pk (don't do this), change the action to update.
+            if unique_object_change_id in change_context.deferred_object_changes:
+                related_changes = ObjectChange.objects.filter(
+                    changed_object_type=changed_object_type,
+                    changed_object_id=changed_object_id,
+                    user=user,
+                    request_id=change_context.change_id,
+                )
+
+                # Skip the database check when deferring object changes
+                if not change_context.defer_object_changes and related_changes.exists():
+                    objectchange = instance.to_objectchange(action)
+                    if objectchange is not None:
+                        most_recent_change = related_changes.order_by("-time").first()
+                        if most_recent_change.action == ObjectChangeActionChoices.ACTION_DELETE:
+                            most_recent_change.action = ObjectChangeActionChoices.ACTION_UPDATE
+                        most_recent_change.object_data = objectchange.object_data
+                        most_recent_change.object_data_v2 = objectchange.object_data_v2
+                        most_recent_change.save()
 
-        else:
-            change_context.deferred_object_changes[unique_object_change_id] = [
-                {"action": action, "instance": instance, "user": user}
-            ]
-            if not change_context.defer_object_changes:
-                objectchange = instance.to_objectchange(action)
-                if objectchange is not None:
-                    objectchange.user = user
-                    objectchange.request_id = change_context.change_id
-                    objectchange.change_context = change_context.context
-                    objectchange.change_context_detail = change_context.context_detail[
-                        :CHANGELOG_MAX_CHANGE_CONTEXT_DETAIL
-                    ]
-                    objectchange.save()
-
-        # restore field cache
-        instance._state.fields_cache = original_cache
+            else:
+                change_context.deferred_object_changes[unique_object_change_id] = [
+                    {"action": action, "instance": instance, "user": user}
+                ]
+                if not change_context.defer_object_changes:
+                    objectchange = instance.to_objectchange(action)
+                    if objectchange is not None:
+                        objectchange.user = user
+                        objectchange.request_id = change_context.change_id
+                        objectchange.change_context = change_context.context
+                        objectchange.change_context_detail = change_context.context_detail[
+                            :CHANGELOG_MAX_CHANGE_CONTEXT_DETAIL
+                        ]
+                        objectchange.save()
+
+            # restore field cache
+            instance._state.fields_cache = original_cache
 
     # Increment metric counters
     if action == ObjectChangeActionChoices.ACTION_CREATE:
@@ -326,71 +354,73 @@ def _handle_deleted_object(sender, instance, **kwargs):
 
     # Record an ObjectChange if applicable
     if hasattr(instance, "to_objectchange"):
+        branch_name = _object_change_branch_name(instance)
         user = change_context.get_user(instance)
 
-        # save a copy of this instance's field cache so it can be restored after serialization
-        # to prevent unexpected behavior when chaining multiple signal handlers
-        original_cache = instance._state.fields_cache.copy()
-
-        changed_object_type = ContentType.objects.get_for_model(instance)
-        changed_object_id = instance.id
-
-        # Generate a unique identifier for this change to stash in the change context
-        # This is used for deferred change logging and for looking up related changes without querying the database
-        unique_object_change_id = f"{changed_object_type.pk}__{changed_object_id}__{user.pk}"
-        save_new_objectchange = True
-
-        # if a change already exists for this change_id, user, and object, update it instead of creating a new one
-        # except in the case that the object was created and deleted in the same change_id
-        # we don't want to create a delete change for an object that never existed
-        if unique_object_change_id in change_context.deferred_object_changes:
-            cached_related_change = change_context.deferred_object_changes[unique_object_change_id][-1]
-            if cached_related_change["action"] != ObjectChangeActionChoices.ACTION_CREATE:
-                cached_related_change["action"] = ObjectChangeActionChoices.ACTION_DELETE
-                save_new_objectchange = False
-
-            related_changes = ObjectChange.objects.filter(
-                changed_object_type=changed_object_type,
-                changed_object_id=changed_object_id,
-                user=user,
-                request_id=change_context.change_id,
-            )
+        with BranchContext(branch_name=branch_name, user=user, autocommit=False):
+            # save a copy of this instance's field cache so it can be restored after serialization
+            # to prevent unexpected behavior when chaining multiple signal handlers
+            original_cache = instance._state.fields_cache.copy()
 
-            # Skip the database check when deferring object changes
-            if not change_context.defer_object_changes and related_changes.exists():
-                objectchange = instance.to_objectchange(ObjectChangeActionChoices.ACTION_DELETE)
-                if objectchange is not None:
-                    most_recent_change = related_changes.order_by("-time").first()
-                    if most_recent_change.action != ObjectChangeActionChoices.ACTION_CREATE:
-                        most_recent_change.action = ObjectChangeActionChoices.ACTION_DELETE
-                        most_recent_change.object_data = objectchange.object_data
-                        most_recent_change.object_data_v2 = objectchange.object_data_v2
-                        most_recent_change.save()
-                        save_new_objectchange = False
-
-        if save_new_objectchange:
-            change_context.deferred_object_changes.setdefault(unique_object_change_id, []).append(
-                {
-                    "action": ObjectChangeActionChoices.ACTION_DELETE,
-                    "instance": instance,
-                    "user": user,
-                    "changed_object_id": changed_object_id,
-                    "changed_object_type": changed_object_type,
-                }
-            )
-            if not change_context.defer_object_changes:
-                objectchange = instance.to_objectchange(ObjectChangeActionChoices.ACTION_DELETE)
-                if objectchange is not None:
-                    objectchange.user = user
-                    objectchange.request_id = change_context.change_id
-                    objectchange.change_context = change_context.context
-                    objectchange.change_context_detail = change_context.context_detail[
-                        :CHANGELOG_MAX_CHANGE_CONTEXT_DETAIL
-                    ]
-                    objectchange.save()
-
-        # restore field cache
-        instance._state.fields_cache = original_cache
+            changed_object_type = ContentType.objects.get_for_model(instance)
+            changed_object_id = instance.id
+
+            # Generate a unique identifier for this change to stash in the change context
+            # This is used for deferred change logging and for looking up related changes without querying the database
+            unique_object_change_id = f"{changed_object_type.pk}__{changed_object_id}__{user.pk}"
+            save_new_objectchange = True
+
+            # if a change already exists for this change_id, user, and object, update it instead of creating a new one
+            # except in the case that the object was created and deleted in the same change_id
+            # we don't want to create a delete change for an object that never existed
+            if unique_object_change_id in change_context.deferred_object_changes:
+                cached_related_change = change_context.deferred_object_changes[unique_object_change_id][-1]
+                if cached_related_change["action"] != ObjectChangeActionChoices.ACTION_CREATE:
+                    cached_related_change["action"] = ObjectChangeActionChoices.ACTION_DELETE
+                    save_new_objectchange = False
+
+                related_changes = ObjectChange.objects.filter(
+                    changed_object_type=changed_object_type,
+                    changed_object_id=changed_object_id,
+                    user=user,
+                    request_id=change_context.change_id,
+                )
+
+                # Skip the database check when deferring object changes
+                if not change_context.defer_object_changes and related_changes.exists():
+                    objectchange = instance.to_objectchange(ObjectChangeActionChoices.ACTION_DELETE)
+                    if objectchange is not None:
+                        most_recent_change = related_changes.order_by("-time").first()
+                        if most_recent_change.action != ObjectChangeActionChoices.ACTION_CREATE:
+                            most_recent_change.action = ObjectChangeActionChoices.ACTION_DELETE
+                            most_recent_change.object_data = objectchange.object_data
+                            most_recent_change.object_data_v2 = objectchange.object_data_v2
+                            most_recent_change.save()
+                            save_new_objectchange = False
+
+            if save_new_objectchange:
+                change_context.deferred_object_changes.setdefault(unique_object_change_id, []).append(
+                    {
+                        "action": ObjectChangeActionChoices.ACTION_DELETE,
+                        "instance": instance,
+                        "user": user,
+                        "changed_object_id": changed_object_id,
+                        "changed_object_type": changed_object_type,
+                    }
+                )
+                if not change_context.defer_object_changes:
+                    objectchange = instance.to_objectchange(ObjectChangeActionChoices.ACTION_DELETE)
+                    if objectchange is not None:
+                        objectchange.user = user
+                        objectchange.request_id = change_context.change_id
+                        objectchange.change_context = change_context.context
+                        objectchange.change_context_detail = change_context.context_detail[
+                            :CHANGELOG_MAX_CHANGE_CONTEXT_DETAIL
+                        ]
+                        objectchange.save()
+
+            # restore field cache
+            instance._state.fields_cache = original_cache
 
     # Increment metric counters
     model_deletes.labels(instance._meta.model_name).inc()

nautobot/extras/tests/test_utils.py

@@ -2,22 +2,26 @@ from unittest import mock
 import uuid
 
 from django.core.cache import cache
+from django.test import override_settings
 
 from nautobot.core.testing import TestCase
 from nautobot.dcim.models import Cable, Device, PowerPort
 from nautobot.extras.choices import JobQueueTypeChoices
-from nautobot.extras.models import JobQueue
+from nautobot.extras.models import JobQueue, JobResult
 from nautobot.extras.registry import registry
 from nautobot.extras.utils import (
     get_base_template,
     get_celery_queues,
     get_worker_count,
     populate_model_features_registry,
+    run_kubernetes_job_and_return_job_result,
 )
 from nautobot.users.models import Token
 
 
 class UtilsTestCase(TestCase):
+    databases = ("default", "job_logs")
+
     def test_get_base_template(self):
         with self.subTest("explicitly specified base_template always wins"):
             self.assertEqual(get_base_template("dcim/device/base.html", Device), "dcim/device/base.html")
@@ -125,3 +129,114 @@ class UtilsTestCase(TestCase):
             original_custom_fields_registry,
             "Registry should be restored to original state",
         )
+
+    @override_settings(
+        KUBERNETES_JOB_POD_NAME="test-pod",
+        KUBERNETES_JOB_POD_NAMESPACE="test-namespace",
+        KUBERNETES_JOB_MANIFEST={
+            "metadata": {"name": "test-job"},
+            "spec": {
+                "template": {
+                    "spec": {
+                        "containers": [
+                            {
+                                "command": [],
+                            }
+                        ]
+                    }
+                }
+            },
+        },
+        KUBERNETES_SSL_CA_CERT_PATH="/path/to/ca.crt",
+        KUBERNETES_TOKEN_PATH="/path/to/token",  # noqa: S106
+        KUBERNETES_DEFAULT_SERVICE_ADDRESS="https://kubernetes.default.svc",
+    )
+    @mock.patch("nautobot.extras.utils.transaction.on_commit")
+    @mock.patch("builtins.open", new_callable=mock.mock_open, read_data="test-token\n")
+    @mock.patch("nautobot.extras.utils.kubernetes.client.BatchV1Api")
+    @mock.patch("nautobot.extras.utils.kubernetes.client.ApiClient")
+    @mock.patch("nautobot.extras.utils.kubernetes.client.Configuration")
+    def test_run_kubernetes_job_and_return_job_result(
+        self,
+        mock_configuration,
+        mock_api_client,
+        mock_batch_api,
+        mock_open,
+        mock_on_commit,
+    ):
+        """Test run_kubernetes_job_and_return_job_result function."""
+        # Setup test data
+        job_result = JobResult.objects.create(
+            name="Test Job",
+            user=self.user,
+        )
+        # Mock the log method to avoid database writes during test
+        job_result.log = mock.Mock()
+        job_kwargs = '{"key": "value"}'
+
+        # Setup kubernetes client mocks
+        mock_config_instance = mock.MagicMock()
+        mock_config_instance.api_key_prefix = {}
+        mock_config_instance.api_key = {}
+        mock_configuration.return_value = mock_config_instance
+
+        mock_api_client_instance = mock.Mock()
+        mock_api_client.return_value.__enter__.return_value = mock_api_client_instance
+        mock_api_client.return_value.__exit__.return_value = None
+
+        mock_api_instance = mock.Mock()
+        mock_batch_api.return_value = mock_api_instance
+
+        # Capture the callback passed to transaction.on_commit
+        commit_callback = None
+
+        def capture_callback(callback):
+            nonlocal commit_callback
+            commit_callback = callback
+            # Execute immediately for testing
+            callback()
+
+        mock_on_commit.side_effect = capture_callback
+
+        # Execute the function
+        result = run_kubernetes_job_and_return_job_result(job_result, job_kwargs)
+
+        # Verify job_result was updated and saved
+        job_result.refresh_from_db()
+        self.assertEqual(job_result.task_kwargs, job_kwargs)
+        self.assertEqual(result, job_result)
+
+        # Verify transaction.on_commit was called
+        mock_on_commit.assert_called_once()
+        self.assertIsNotNone(commit_callback)
+
+        # Verify kubernetes configuration was set up correctly
+        mock_configuration.assert_called_once()
+        self.assertEqual(mock_config_instance.host, "https://kubernetes.default.svc")
+        self.assertEqual(mock_config_instance.ssl_ca_cert, "/path/to/ca.crt")
+        self.assertEqual(mock_config_instance.api_key_prefix["authorization"], "Bearer")
+        self.assertEqual(mock_config_instance.api_key["authorization"], "test-token")
+
+        # Verify ApiClient was used as context manager
+        mock_api_client.assert_called_once_with(mock_config_instance)
+
+        # Verify BatchV1Api was created with the api_client_instance
+        mock_batch_api.assert_called_once_with(mock_api_client_instance)
+
+        # Verify the pod manifest was modified correctly
+        mock_api_instance.create_namespaced_job.assert_called_once()
+        create_call = mock_api_instance.create_namespaced_job.call_args
+        body = create_call[1]["body"]
+        self.assertEqual(body["metadata"]["name"], f"nautobot-job-{job_result.pk}")
+        self.assertEqual(
+            body["spec"]["template"]["spec"]["containers"][0]["command"],
+            ["nautobot-server", "runjob_with_job_result", str(job_result.pk)],
+        )
+        self.assertEqual(create_call[1]["namespace"], "test-namespace")
+
+        # Verify token file was opened
+        mock_open.assert_called_once_with("/path/to/token", "r", encoding="utf-8")
+
+        # Verify job_result.log was called (checking for log messages)
+        self.assertEqual(job_result.log.call_count, 1)
+        self.assertIn("Creating job pod", str(job_result.log.call_args_list[0]))

nautobot/extras/utils.py

@@ -668,7 +668,7 @@ def refresh_job_model_from_job_class(job_model_class, job_class, job_queue_class
     return (job_model, created)
 
 
-def run_kubernetes_job_and_return_job_result(job_queue, job_result, job_kwargs):
+def run_kubernetes_job_and_return_job_result(job_result, job_kwargs):
     """
     Pass the job to a kubernetes pod and execute it there.
     """
@@ -678,17 +678,6 @@ def run_kubernetes_job_and_return_job_result(job_queue, job_result, job_kwargs):
     pod_ssl_ca_cert = settings.KUBERNETES_SSL_CA_CERT_PATH
     pod_token = settings.KUBERNETES_TOKEN_PATH
 
-    configuration = kubernetes.client.Configuration()
-    configuration.host = settings.KUBERNETES_DEFAULT_SERVICE_ADDRESS
-    configuration.ssl_ca_cert = pod_ssl_ca_cert
-    with open(pod_token, "r") as token_file:
-        token = token_file.read().strip()
-    # configure API Key authorization: BearerToken
-    configuration.api_key_prefix["authorization"] = "Bearer"
-    configuration.api_key["authorization"] = token
-    with kubernetes.client.ApiClient(configuration) as api_client:
-        api_instance = kubernetes.client.BatchV1Api(api_client)
-
     job_result.task_kwargs = job_kwargs
     job_result.save()
     pod_manifest["metadata"]["name"] = "nautobot-job-" + str(job_result.pk)
@@ -697,10 +686,23 @@ def run_kubernetes_job_and_return_job_result(job_queue, job_result, job_kwargs):
         "runjob_with_job_result",
         f"{job_result.pk}",
     ]
-    job_result.log(f"Creating job pod {pod_name} in namespace {pod_namespace}")
-    api_instance.create_namespaced_job(body=pod_manifest, namespace=pod_namespace)
-    job_result.log(f"Reading job pod {pod_name} in namespace {pod_namespace}")
-    api_instance.read_namespaced_job(name="nautobot-job-" + str(job_result.pk), namespace=pod_namespace)
+
+    def create_kubernetes_job():
+        """Create and read the Kubernetes job after the transaction commits."""
+        configuration = kubernetes.client.Configuration()
+        configuration.host = settings.KUBERNETES_DEFAULT_SERVICE_ADDRESS
+        configuration.ssl_ca_cert = pod_ssl_ca_cert
+        with open(pod_token, "r", encoding="utf-8") as token_file:
+            token = token_file.read().strip()
+        # configure API Key authorization: BearerToken
+        configuration.api_key_prefix["authorization"] = "Bearer"
+        configuration.api_key["authorization"] = token
+        with kubernetes.client.ApiClient(configuration) as api_client:
+            api_instance = kubernetes.client.BatchV1Api(api_client)
+            job_result.log(f"Creating job pod {pod_name} in namespace {pod_namespace}")
+            api_instance.create_namespaced_job(body=pod_manifest, namespace=pod_namespace)
+
+    transaction.on_commit(create_kubernetes_job)
     return job_result
 
 

nautobot/extras/views.py

@@ -820,7 +820,6 @@ class ComputedFieldUIViewSet(NautobotUIViewSet):
     serializer_class = serializers.ComputedFieldSerializer
     table_class = tables.ComputedFieldTable
     queryset = ComputedField.objects.all()
-    action_buttons = ("add",)
     object_detail_content = object_detail.ObjectDetailContent(
         panels=(
             object_detail.ObjectFieldsPanel(
@@ -1246,7 +1245,6 @@ class CustomFieldUIViewSet(NautobotUIViewSet):
     form_class = forms.CustomFieldForm
     table_class = tables.CustomFieldTable
     template_name = "extras/customfield_update.html"
-    action_buttons = ("add",)
 
     class CustomFieldObjectFieldsPanel(object_detail.ObjectFieldsPanel):
         def render_value(self, key, value, context):
@@ -1392,7 +1390,6 @@ class DynamicGroupUIViewSet(NautobotUIViewSet):
     queryset = DynamicGroup.objects.all()
     serializer_class = serializers.DynamicGroupSerializer
     table_class = tables.DynamicGroupTable
-    action_buttons = ("add",)
 
     def get_extra_context(self, request, instance):
         context = super().get_extra_context(request, instance)
@@ -1896,23 +1893,14 @@ class GitRepositoryUIViewSet(NautobotUIViewSet):
 #
 
 
-class GraphQLQueryUIViewSet(
-    ObjectDetailViewMixin,
-    ObjectListViewMixin,
-    ObjectEditViewMixin,
-    ObjectDestroyViewMixin,
-    ObjectBulkDestroyViewMixin,
-    ObjectChangeLogViewMixin,
-    ObjectDataComplianceViewMixin,
-    ObjectNotesViewMixin,
-):
+class GraphQLQueryUIViewSet(NautobotUIViewSet):
     filterset_form_class = forms.GraphQLQueryFilterForm
     queryset = GraphQLQuery.objects.all()
     form_class = forms.GraphQLQueryForm
     filterset_class = filters.GraphQLQueryFilterSet
     serializer_class = serializers.GraphQLQuerySerializer
     table_class = tables.GraphQLQueryTable
-    action_buttons = ("add",)
+    action_buttons = ("add", "export", "import")
 
     object_detail_content = object_detail.ObjectDetailContent(
         panels=(

nautobot/ipam/apps.py

@@ -9,6 +9,7 @@ class IPAMConfig(NautobotConfig):
         "ipaddress",
         "namespace",
         "prefix",
+        "service",
         "vlan",
         "vrf",
     ]

nautobot/project-static/docs/development/core/release-checklist.html

@@ -13736,6 +13736,8 @@
 </div>
 <h3 id="sync-changes-into-next">Sync Changes into <code>next</code><a class="headerlink" href="#sync-changes-into-next" title="Permanent link">¶</a></h3>
 <p>After the main-to-develop pull request is merged into <code>develop</code>, create a new branch off of <code>next</code> (typically named <code>develop-to-next-post-&lt;x.y.z&gt;</code>) and <code>git merge develop</code>. Resolve any merge conflicts as appropriate (if you're lucky, there may only be one, a version number clash in <code>pyproject.toml</code>), then open a pull request to <code>next</code>.</p>
+<p>When resolving conflicts, always keep the Nautobot app version number from the <strong>current branch</strong> (not the incoming one). Once conflicts are resolved, open a pull request to <code>next</code>.</p>
+<p>During the pull request, the CI pipeline may fail at the <strong>changelog</strong> step. This is expected in this case and should not be a cause for concern (the error can be safely ignored).</p>
 <div class="admonition important">
 <p class="admonition-title">Important</p>
 <p>Do not squash merge this branch into <code>next</code>. Make sure to select <code>Create a merge commit</code> when merging in GitHub.</p>