tests: Patch unique compact ops in robustness

Signed-off-by: Ashwani Kumar Kamal <[email protected]>

Author: sneaky-potato

tests/robustness/model/types.go

@@ -84,6 +84,10 @@ type DeleteOptions struct {
 	Key string
 }
 
+type CompactOptions struct {
+    Revision int64
+}
+
 type TxnRequest struct {
 	Conditions          []EtcdCondition
 	OperationsOnSuccess []EtcdOperation
@@ -113,6 +117,7 @@ const (
 	RangeOperation  OperationType = "range-operation"
 	PutOperation    OperationType = "put-operation"
 	DeleteOperation OperationType = "delete-operation"
+    CompactOperation OperationType = "compact-operation"
 )
 
 type LeaseGrantRequest struct {

tests/robustness/validate/patch_history.go

@@ -32,14 +32,17 @@ type patchArgs struct {
 }
 
 func patchLinearizableOperations(operations []porcupine.Operation, reports []report.ClientReport, persistedRequests []model.EtcdRequest) []porcupine.Operation {
-	putRevision, delRevision := watchRevisions(reports)
+	putRevision := watchRevisions(reports)
 	persistedPutCount := countPersistedPuts(persistedRequests)
 	clientPutCount := countClientPuts(reports)
 
 	persistedDeleteCount := countPersistedDeletes(persistedRequests)
 	clientDeleteCount := countClientDeletes(reports)
 
-	putReturnTime, delReturnTime := uniqueOperationReturnTime(operations, persistedRequests, clientPutCount, clientDeleteCount)
+	persistedCompactCount := countPersistedCompacts(persistedRequests)
+	clientCompactCount := countClientCompacts(reports)
+
+	putReturnTime, delReturnTime, compactReturnTime := uniqueOperationReturnTime(operations, persistedRequests, clientPutCount, clientDeleteCount, clientCompactCount)
 
 	putArgs := make(map[model.PutOptions]patchArgs)
 	for opts, c := range clientPutCount {
@@ -56,18 +59,24 @@ func patchLinearizableOperations(operations []porcupine.Operation, reports []rep
 			clientCount:    c,
 			persistedCount: persistedDeleteCount[opts],
 			returnTime:     delReturnTime[opts],
-			revision:       delRevision[opts],
+		}
+	}
+	compactArgs := make(map[model.CompactOptions]patchArgs)
+	for opts, c := range clientCompactCount {
+		compactArgs[opts] = patchArgs{
+			clientCount:    c,
+			persistedCount: persistedCompactCount[opts],
+			returnTime:     compactReturnTime[opts],
 		}
 	}
 
 	return patchOperations(
-		operations, putArgs, delArgs,
+		operations, putArgs, delArgs, compactArgs,
 	)
 }
 
-func watchRevisions(reports []report.ClientReport) (map[model.PutOptions]int64, map[model.DeleteOptions]int64) {
+func watchRevisions(reports []report.ClientReport) (map[model.PutOptions]int64) {
 	putRevisions := map[model.PutOptions]int64{}
-	delRevisions := map[model.DeleteOptions]int64{}
 
 	for _, client := range reports {
 		for _, watch := range client.Watch {
@@ -79,27 +88,40 @@ func watchRevisions(reports []report.ClientReport) (map[model.PutOptions]int64,
 						kv := model.PutOptions{Key: event.Key, Value: event.Value}
 						putRevisions[kv] = event.Revision
 					case model.DeleteOperation:
-						// Delete events are also created by leaseRevoke rquest.
+						// Don't track delete revisions - they can be triggered by leaseRevoke
+						// So we can't reliably attribute them to explicit delete operations
+					case model.CompactOperation:
 					default:
 						panic(fmt.Sprintf("unknown event type %q", event.Type))
 					}
 				}
 			}
 		}
 	}
-	return putRevisions, delRevisions
+	return putRevisions
 }
 
 func patchOperations(
 	operations []porcupine.Operation,
 	putArgs map[model.PutOptions]patchArgs,
 	delArgs map[model.DeleteOptions]patchArgs,
+	compactArgs map[model.CompactOptions]patchArgs,
 ) []porcupine.Operation {
 	newOperations := make([]porcupine.Operation, 0, len(operations))
 
 	for _, op := range operations {
 		request := op.Input.(model.EtcdRequest)
 		resp := op.Output.(model.MaybeEtcdResponse)
+		
+		if request.Type == model.Compact {
+			kv := model.CompactOptions{Revision: request.Compact.Revision}
+			if arg, ok := compactArgs[kv]; ok && arg.clientCount == 1 && arg.returnTime > 0 {
+				op.Return = min(op.Return, arg.returnTime-1)
+			}
+			newOperations = append(newOperations, op)
+			continue
+		}
+		
 		if resp.Error == "" || request.Type != model.Txn {
 			// Cannot patch those requests.
 			newOperations = append(newOperations, op)
@@ -150,9 +172,13 @@ func patchOperations(
 				panic(fmt.Sprintf("unknown operation type %q", etcdOp.Type))
 			}
 		}
+		if request.Type == model.Compact {
+			newOperations = append(newOperations, op)
+			continue
+		}
+
 		if isUniqueTxn(request.Txn, putArgs, delArgs) {
 			if !persisted {
-				// Remove non persisted operations
 				continue
 			}
 			if txnRevision != 0 {
@@ -198,16 +224,28 @@ func hasUniqueWriteOperation(ops []model.EtcdOperation, putArgs map[model.PutOpt
 				return true
 			}
 		case model.RangeOperation:
+		case model.CompactOperation:
 		default:
 			panic(fmt.Sprintf("unknown operation type %q", operation.Type))
 		}
 	}
 	return false
 }
 
-func uniqueOperationReturnTime(allOperations []porcupine.Operation, persistedRequests []model.EtcdRequest, clientPutCount map[model.PutOptions]int64, clientDeleteCount map[model.DeleteOptions]int64) (map[model.PutOptions]int64, map[model.DeleteOptions]int64) {
+func uniqueOperationReturnTime(
+	allOperations []porcupine.Operation,
+	persistedRequests []model.EtcdRequest,
+	clientPutCount map[model.PutOptions]int64,
+	clientDeleteCount map[model.DeleteOptions]int64,
+	clientCompactCount map[model.CompactOptions]int64,
+) (
+	map[model.PutOptions]int64,
+	map[model.DeleteOptions]int64,
+	map[model.CompactOptions]int64,
+) {
 	putTimes := map[model.PutOptions]int64{}
 	delTimes := map[model.DeleteOptions]int64{}
+	compactTimes := map[model.CompactOptions]int64{}
 	var lastReturnTime int64
 	for _, op := range allOperations {
 		request := op.Input.(model.EtcdRequest)
@@ -237,6 +275,13 @@ func uniqueOperationReturnTime(allOperations []porcupine.Operation, persistedReq
 		case model.LeaseGrant:
 		case model.LeaseRevoke:
 		case model.Compact:
+			kv := model.CompactOptions{Revision: request.Compact.Revision}
+			if clientCompactCount[kv] > 1 {
+				continue
+			}
+			if returnTime, ok := compactTimes[kv]; !ok || returnTime > op.Return {
+				compactTimes[kv] = op.Return
+			}
 		case model.Defragment:
 		default:
 			panic(fmt.Sprintf("Unknown request type: %q", request.Type))
@@ -278,11 +323,19 @@ func uniqueOperationReturnTime(allOperations []porcupine.Operation, persistedReq
 		case model.LeaseGrant:
 		case model.LeaseRevoke:
 		case model.Compact:
+			kv := model.CompactOptions{Revision: request.Compact.Revision}
+			if clientCompactCount[kv] > 1 {
+				continue
+			}
+			if returnTime, ok := compactTimes[kv]; ok {
+				lastReturnTime = min(returnTime, lastReturnTime)
+				compactTimes[kv] = lastReturnTime
+			}
 		default:
 			panic(fmt.Sprintf("Unknown request type: %q", request.Type))
 		}
 	}
-	return putTimes, delTimes
+	return putTimes, delTimes, compactTimes
 }
 
 func countClientPuts(reports []report.ClientReport) map[model.PutOptions]int64 {
@@ -313,6 +366,7 @@ func countPuts(counter map[model.PutOptions]int64, request model.EtcdRequest) {
 				kv := model.PutOptions{Key: operation.Put.Key, Value: operation.Put.Value}
 				counter[kv]++
 			case model.DeleteOperation:
+			case model.CompactOperation:
 			case model.RangeOperation:
 			default:
 				panic(fmt.Sprintf("unknown operation type %q", operation.Type))
@@ -357,3 +411,32 @@ func countDeletes(counter map[model.DeleteOptions]int64, request model.EtcdReque
 		}
 	}
 }
+
+func countClientCompacts(reports []report.ClientReport) map[model.CompactOptions]int64 {
+	counter := map[model.CompactOptions]int64{}
+	for _, client := range reports {
+		for _, op := range client.KeyValue {
+			request := op.Input.(model.EtcdRequest)
+			countCompacts(counter, request)
+		}
+	}
+	return counter
+}
+
+func countPersistedCompacts(requests []model.EtcdRequest) map[model.CompactOptions]int64 {
+	counter := map[model.CompactOptions]int64{}
+	for _, req := range requests {
+		countCompacts(counter, req)
+	}
+	return counter
+}
+
+func countCompacts(counter map[model.CompactOptions]int64, request model.EtcdRequest) {
+	switch request.Type {
+	case model.Compact:
+		opts := model.CompactOptions{
+			Revision: request.Compact.Revision,
+		}
+		counter[opts]++
+	}
+}