Made template diffing a bit smarter.

.changelog/11378.txt

@@ -0,0 +1,3 @@
+```release-note:improvement
+plan: Smarter diffing of template stanzas
+```

nomad/structs/diff.go

@@ -516,14 +516,8 @@ func (t *Task) Diff(other *Task, contextual bool) (*TaskDiff, error) {
 		diff.Objects = append(diff.Objects, vDiff)
 	}
 
-	// Template diff
-	tmplDiffs := primitiveObjectSetDiff(
-		interfaceSlice(t.Templates),
-		interfaceSlice(other.Templates),
-		nil,
-		"Template",
-		contextual)
-	if tmplDiffs != nil {
+	// Templates diff
+	if tmplDiffs := templateDiffs(t.Templates, other.Templates, contextual); tmplDiffs != nil {
 		diff.Objects = append(diff.Objects, tmplDiffs...)
 	}
 
@@ -769,6 +763,73 @@ func findServiceMatch(service *Service, serviceIndex int, services []*Service, m
 	return indexMatch
 }
 
+// templateDiff returns the diff of two template objects. If contextual diff is
+// enabled, all fields will be returned, even if no diff occurred.
+func templateDiff(old, new *Template, contextual bool) *ObjectDiff {
+	diff := &ObjectDiff{Type: DiffTypeNone, Name: "Template"}
+	var oldPrimitiveFlat, newPrimitiveFlat map[string]string
+
+	if reflect.DeepEqual(old, new) {
+		return nil
+	} else if old == nil {
+		diff.Type = DiffTypeAdded
+		newPrimitiveFlat = flatmap.Flatten(new, nil, true)
+	} else if new == nil {
+		diff.Type = DiffTypeDeleted
+		oldPrimitiveFlat = flatmap.Flatten(old, nil, true)
+	} else {
+		diff.Type = DiffTypeEdited
+		oldPrimitiveFlat = flatmap.Flatten(old, nil, true)
+		newPrimitiveFlat = flatmap.Flatten(new, nil, true)
+	}
+
+	// Diff the primitive fields.
+	diff.Fields = fieldDiffs(oldPrimitiveFlat, newPrimitiveFlat, contextual)
+
+	return diff
+}
+
+// templateDiffs diffs a set of templates. If contextual diff is enabled, unchanged
+// fields within objects nested in the tasks will be returned.
+func templateDiffs(old, new []*Template, contextual bool) []*ObjectDiff {
+	// Handle trivial case.
+	if len(old) == 1 && len(new) == 1 {
+		if diff := templateDiff(old[0], new[0], contextual); diff != nil {
+			return []*ObjectDiff{diff}
+		}
+		return nil
+	}
+
+	oldMap := make(map[string]*Template, len(old))
+	newMap := make(map[string]*Template, len(new))
+	for _, o := range old {
+		oldMap[o.DestPath] = o
+	}
+	for _, n := range new {
+		newMap[n.DestPath] = n
+	}
+
+	var diffs []*ObjectDiff
+	for path, oldTemplate := range oldMap {
+		// Diff the same, deleted and edited
+		if diff := templateDiff(oldTemplate, newMap[path], contextual); diff != nil {
+			diffs = append(diffs, diff)
+		}
+	}
+
+	for path, newTemplate := range newMap {
+		// Diff the added
+		if old, ok := oldMap[path]; !ok {
+			if diff := templateDiff(old, newTemplate, contextual); diff != nil {
+				diffs = append(diffs, diff)
+			}
+		}
+	}
+
+	sort.Sort(ObjectDiffs(diffs))
+	return diffs
+}
+
 // serviceCheckDiff returns the diff of two service check objects. If contextual
 // diff is enabled, all fields will be returned, even if no diff occurred.
 func serviceCheckDiff(old, new *ServiceCheck, contextual bool) *ObjectDiff {

nomad/structs/diff_test.go

@@ -6914,7 +6914,7 @@ func TestTaskDiff(t *testing.T) {
 					{
 						SourcePath:   "foo",
 						DestPath:     "bar",
-						EmbeddedTmpl: "baz",
+						EmbeddedTmpl: "baz new",
 						ChangeMode:   "bam",
 						ChangeSignal: "SIGHUP",
 						Splay:        1,
@@ -6934,6 +6934,18 @@ func TestTaskDiff(t *testing.T) {
 			Expected: &TaskDiff{
 				Type: DiffTypeEdited,
 				Objects: []*ObjectDiff{
+					{
+						Type: DiffTypeEdited,
+						Name: "Template",
+						Fields: []*FieldDiff{
+							{
+								Type: DiffTypeEdited,
+								Name: "EmbeddedTmpl",
+								Old:  "baz",
+								New:  "baz new",
+							},
+						},
+					},
 					{
 						Type: DiffTypeAdded,
 						Name: "Template",