Merge pull request #108 from apgrucza/unique-key

feat(resource): interface method for unique-key

Author: ekristen

pkg/queue/item.go

@@ -113,24 +113,27 @@ func (i *Item) Equals(o resource.Resource) bool {
 		return false
 	}
 
-	iGetter, iOK := i.Resource.(resource.PropertyGetter)
-	oGetter, oOK := o.(resource.PropertyGetter)
-	if iOK != oOK {
-		return false
-	}
+	// Compare unique keys if present
+	iKeyGetter, iOK := i.Resource.(resource.UniqueKeyGetter)
+	oKeyGetter, oOK := o.(resource.UniqueKeyGetter)
 	if iOK && oOK {
-		return iGetter.Properties().Equals(oGetter.Properties())
+		return iKeyGetter.UniqueKey() == oKeyGetter.UniqueKey()
 	}
 
+	// Fall back to legacy string comparison (may not handle case where resource is recreated during nuke)
 	iStringer, iOK := i.Resource.(resource.LegacyStringer)
 	oStringer, oOK := o.(resource.LegacyStringer)
-	if iOK != oOK {
-		return false
-	}
 	if iOK && oOK {
 		return iStringer.String() == oStringer.String()
 	}
 
+	// Fall back to property comparison (does not handle case where properties change during nuke)
+	iPropertyGetter, iOK := i.Resource.(resource.PropertyGetter)
+	oPropertyGetter, oOK := o.(resource.PropertyGetter)
+	if iOK && oOK {
+		return iPropertyGetter.Properties().Equals(oPropertyGetter.Properties())
+	}
+
 	return false
 }
 

pkg/queue/item_test.go

@@ -281,6 +281,45 @@ func Test_ItemEqualStringer(t *testing.T) {
 
 // ------------------------------------------------------------------------
 
+type TestItemResourceUniqueKey struct {
+	ID    string
+	State string
+}
+
+func (r *TestItemResourceUniqueKey) Remove(_ context.Context) error {
+	return nil
+}
+func (r *TestItemResourceUniqueKey) Properties() types.Properties {
+	return types.NewProperties().Set("ID", r.ID).Set("State", r.State)
+}
+func (r *TestItemResourceUniqueKey) UniqueKey() string {
+	return r.ID
+}
+
+func Test_ItemEqualUniqueKey(t *testing.T) {
+	r1 := &TestItemResourceUniqueKey{
+		ID:    "i-01b489457a60298dd",
+		State: "running",
+	}
+
+	r2 := &TestItemResourceUniqueKey{
+		ID:    "i-01b489457a60298dd", // Same ID
+		State: "stopping",            // Different state (should be ignored)
+	}
+
+	i := &Item{Resource: r1}
+	assert.True(t, i.Equals(r2), "Resources with same UniqueKey should be equal")
+
+	r3 := &TestItemResourceUniqueKey{
+		ID:    "i-1234567890abcdef0", // Different ID
+		State: "running",             // Same state (should be ignored)
+	}
+
+	assert.False(t, i.Equals(r3), "Resources with different UniqueKey should not be equal")
+}
+
+// ------------------------------------------------------------------------
+
 type TestItemResourceNothing struct{}
 
 func (r *TestItemResourceNothing) Remove(_ context.Context) error {

pkg/resource/resource.go

@@ -1,5 +1,10 @@
 // Package resource provides a way to interact with resources. This provides multiple interfaces to test against
 // as resources can optionally implement these interfaces.
+//
+// All new resources should implement Properties() and UniqueKey(), but not String(). Without UniqueKey(), libnuke
+// attempts to use Properties() to match resources, which does not work if any of the properties change in value during
+// the run. UniqueKey() is also useful in older resources that still implement String(), to prevent libnuke from
+// mistakenly identifying resources that were recreated with the same String() value after being nuked.
 package resource
 
 import (
@@ -33,6 +38,14 @@ type SettingsGetter interface {
 	Settings(setting *settings.Setting)
 }
 
+// UniqueKeyGetter is an interface that allows a resource to provide a key that uniquely identifies an instance of a
+// resource. UniqueKey() can return any field that uniquely identifies the resource and whose value is random or non-
+// deterministic. For example, an EC2 instance ID (i-1234567890abcdef0), or resource name with creation time appended.
+type UniqueKeyGetter interface {
+	Resource
+	UniqueKey() string
+}
+
 // HandleWaitHook is an interface that allows a resource to handle waiting for a resource to be deleted.
 // This is useful for resources that may take a while to delete, typically where the delete operation happens
 // asynchronously from the initial delete command. This allows libnuke to not block during the delete operation.