Add ability to Squash Changes when merging

netbox_branching/api/views.py

@@ -78,7 +78,8 @@ def merge(self, request, pk):
         job = MergeBranchJob.enqueue(
             instance=branch,
             user=request.user,
-            commit=commit
+            commit=commit,
+            job_timeout=MergeBranchJob.Meta.job_timeout
         )
 
         return Response(JobSerializer(job, context={'request': request}).data)

netbox_branching/choices.py

@@ -46,6 +46,16 @@ class BranchStatusChoices(ChoiceSet):
     )
 
 
+class BranchMergeStrategyChoices(ChoiceSet):
+    ITERATIVE = 'iterative'
+    SQUASH = 'squash'
+
+    CHOICES = (
+        (ITERATIVE, _('Iterative')),
+        (SQUASH, _('Squash')),
+    )
+
+
 class BranchEventTypeChoices(ChoiceSet):
     PROVISIONED = 'provisioned'
     SYNCED = 'synced'

netbox_branching/forms/misc.py

@@ -1,6 +1,7 @@
 from django import forms
 from django.utils.translation import gettext_lazy as _
 
+from netbox_branching.choices import BranchMergeStrategyChoices
 from netbox_branching.models import ChangeDiff
 
 __all__ = (
@@ -20,14 +21,24 @@ class BranchActionForm(forms.Form):
         label=_('Commit changes'),
         help_text=_('Leave unchecked to perform a dry run')
     )
+    merge_strategy = forms.ChoiceField(
+        choices=BranchMergeStrategyChoices,
+        initial=BranchMergeStrategyChoices.ITERATIVE,
+        label=_('Merge Strategy'),
+        help_text=_('Strategy to use when merging changes.')
+    )
 
-    def __init__(self, branch, *args, allow_commit=True, **kwargs):
+    def __init__(self, branch, *args, allow_commit=True, action=None, **kwargs):
         self.branch = branch
         super().__init__(*args, **kwargs)
 
         if not allow_commit:
             self.fields['commit'].disabled = True
 
+        # Only show merge_strategy for merge operations, not revert
+        if action == 'revert':
+            del self.fields['merge_strategy']
+
     def clean(self):
         super().clean()
 

netbox_branching/jobs.py

@@ -51,6 +51,12 @@ class SyncBranchJob(JobRunner):
     """
     class Meta:
         name = 'Sync branch'
+        job_timeout = 3600  # 1 hour - increased for large syncs
+
+    @property
+    def job_timeout(self):
+        """Return the job timeout from Meta."""
+        return getattr(self.Meta, 'job_timeout', None)
 
     def _disconnect_signal_receivers(self):
         """
@@ -101,6 +107,12 @@ class MergeBranchJob(JobRunner):
     """
     class Meta:
         name = 'Merge branch'
+        job_timeout = 3600  # 1 hour (in seconds) - increased from default 300s for large merges
+
+    @property
+    def job_timeout(self):
+        """Return the job timeout from Meta."""
+        return getattr(self.Meta, 'job_timeout', None)
 
     def run(self, commit=True, *args, **kwargs):
         # Initialize logging
@@ -122,6 +134,12 @@ class RevertBranchJob(JobRunner):
     """
     class Meta:
         name = 'Revert branch'
+        job_timeout = 3600  # 1 hour - increased for large reverts
+
+    @property
+    def job_timeout(self):
+        """Return the job timeout from Meta."""
+        return getattr(self.Meta, 'job_timeout', None)
 
     def run(self, commit=True, *args, **kwargs):
         # Initialize logging

netbox_branching/merge_strategies/__init__.py

@@ -0,0 +1,14 @@
+"""
+Merge strategy implementations for branch operations.
+"""
+from .strategy import MergeStrategy, get_merge_strategy
+from .iterative import IterativeMergeStrategy
+from .squash import SquashMergeStrategy
+
+
+__all__ = (
+    'MergeStrategy',
+    'IterativeMergeStrategy',
+    'SquashMergeStrategy',
+    'get_merge_strategy',
+)

netbox_branching/merge_strategies/iterative.py

@@ -0,0 +1,58 @@
+"""
+Iterative merge strategy implementation.
+"""
+from django.db import DEFAULT_DB_ALIAS
+
+from netbox.context_managers import event_tracking
+from utilities.exceptions import AbortTransaction
+
+from .strategy import MergeStrategy
+
+
+__all__ = (
+    'IterativeMergeStrategy',
+)
+
+
+class IterativeMergeStrategy(MergeStrategy):
+    """
+    Iterative merge strategy that applies/reverts changes one at a time in chronological order.
+    """
+
+    def merge(self, branch, changes, request, commit, logger):
+        """
+        Apply changes iteratively in chronological order.
+        """
+        models = set()
+
+        for change in changes:
+            models.add(change.changed_object_type.model_class())
+            with event_tracking(request):
+                request.id = change.request_id
+                request.user = change.user
+                change.apply(branch, using=DEFAULT_DB_ALIAS, logger=logger)
+
+        if not commit:
+            raise AbortTransaction()
+
+        branch._cleanup(models)
+
+    def revert(self, branch, changes, request, commit, logger):
+        """
+        Undo changes iteratively (one at a time) in reverse chronological order.
+        """
+        models = set()
+
+        # Undo each change from the Branch
+        for change in changes:
+            models.add(change.changed_object_type.model_class())
+            with event_tracking(request):
+                request.id = change.request_id
+                request.user = change.user
+                change.undo(branch, logger=logger)
+
+        if not commit:
+            raise AbortTransaction()
+
+        # Perform cleanup tasks
+        branch._cleanup(models)