Create findMatchingLogs and refactor all uses of hasMatchingLog. Refactor QueryLog to use QueryAllLogs.

Author: franciscovalentecastro

integration_test/gce-testing-internal/gce/gce_testing.go

@@ -604,11 +604,10 @@ func AssertMetricMissing(ctx context.Context, logger *log.Logger, vm *VM, metric
 	return nil
 }
 
-// hasMatchingLog looks in the logging backend for a log matching the given query,
+// findMatchingLogs looks in the logging backend for a log matching the given query,
 // over the trailing time interval specified by the given window.
-// Returns a boolean indicating whether the log was present in the backend,
-// plus all the matching log entries found, or an error if the lookup failed.
-func hasMatchingLog(ctx context.Context, logger *log.Logger, vm *VM, logNameRegex string, window time.Duration, query string) (bool, []*cloudlogging.Entry, error) {
+// Returns all the matching log entries found, or an error if the lookup failed.
+func findMatchingLogs(ctx context.Context, logger *log.Logger, vm *VM, logNameRegex string, window time.Duration, query string) ([]*cloudlogging.Entry, error) {
 	start := time.Now().Add(-window)
 
 	t := start.Format(time.RFC3339)
@@ -620,10 +619,9 @@ func hasMatchingLog(ctx context.Context, logger *log.Logger, vm *VM, logNameRege
 
 	logClient, err := logClients.new(vm.Project)
 	if err != nil {
-		return false, nil, fmt.Errorf("hasMatchingLog() failed to obtain logClient for project %v: %v", vm.Project, err)
+		return nil, fmt.Errorf("findMatchingLogs() failed to obtain logClient for project %v: %v", vm.Project, err)
 	}
 	it := logClient.Entries(ctx, logadmin.Filter(filter))
-	found := false
 
 	var matchingLogs []*cloudlogging.Entry
 	// Loop through the iterator printing out each matching log entry.
@@ -634,16 +632,12 @@ func hasMatchingLog(ctx context.Context, logger *log.Logger, vm *VM, logNameRege
 			break
 		}
 		if err != nil {
-			return false, nil, err
+			return nil, err
 		}
 		logger.Printf("Found matching log entry: %v", entry)
-		found = true
 		matchingLogs = append(matchingLogs, entry)
 	}
-	if found && len(matchingLogs) == 0 {
-		return false, nil, fmt.Errorf("hasMatchingLog() internal logic error: found is true but matchingLogs is empty")
-	}
-	return found, matchingLogs, nil
+	return matchingLogs, nil
 }
 
 // WaitForLog looks in the logging backend for a log matching the given query,
@@ -666,63 +660,52 @@ func shouldRetryHasMatchingLog(err error) bool {
 // Returns the first log entry found, or an error if the log could not be
 // found after some retries.
 func QueryLog(ctx context.Context, logger *log.Logger, vm *VM, logNameRegex string, window time.Duration, query string, maxAttempts int) (*cloudlogging.Entry, error) {
-	for attempt := 1; attempt <= maxAttempts; attempt++ {
-		found, matchingLogs, err := hasMatchingLog(ctx, logger, vm, logNameRegex, window, query)
-		if found {
-			if len(matchingLogs) > 0 {
-				// Success.
-				return matchingLogs[0], nil
-			}
-			// This should never happen if we found at least one log (found == true).
-			return nil, fmt.Errorf("QueryLog() internal logic error: found is true but matchingLogs is empty")
-		}
-		logger.Printf("Query returned found=%v, err=%v, attempt=%d", found, err, attempt)
-		if err != nil && !shouldRetryHasMatchingLog(err) {
-			// A non-retryable error.
-			return nil, fmt.Errorf("QueryLog() failed: %v", err)
-		}
-		// found was false, or we hit a retryable error.
-		time.Sleep(logQueryBackoffDuration)
+	matchingLogs, err := QueryAllLogs(ctx, logger, vm, logNameRegex, window, query, maxAttempts)
+	if err != nil {
+		return nil, err
+	}
+	if len(matchingLogs) > 0 {
+		return matchingLogs[0], nil
 	}
 	return nil, fmt.Errorf("QueryLog() failed: %s not found, exhausted retries", logNameRegex)
 }
 
-// QueryAllLog looks in the logging backend for a log matching the given query,
+// QueryAllLog looks in the logging backend for logs matching the given query,
 // over the trailing time interval specified by the given window.
-// Returns all the log entries found, or an error if the log could not be
+// Returns all the log entries found, or an error if no log could not be
 // found after some retries.
 func QueryAllLogs(ctx context.Context, logger *log.Logger, vm *VM, logNameRegex string, window time.Duration, query string, maxAttempts int) ([]*cloudlogging.Entry, error) {
 	for attempt := 1; attempt <= maxAttempts; attempt++ {
-		found, matchingLogs, err := hasMatchingLog(ctx, logger, vm, logNameRegex, window, query)
-		if found {
+		matchingLogs, err := findMatchingLogs(ctx, logger, vm, logNameRegex, window, query)
+		if len(matchingLogs) > 0 {
 			// Success.
 			return matchingLogs, nil
 		}
-		logger.Printf("Query returned found=%v, err=%v, attempt=%d", found, err, attempt)
+		logger.Printf("Query returned matchingLogs=%v, err=%v, attempt=%d", matchingLogs, err, attempt)
 		if err != nil && !shouldRetryHasMatchingLog(err) {
 			// A non-retryable error.
 			return nil, fmt.Errorf("QueryLog() failed: %v", err)
 		}
 		// found was false, or we hit a retryable error.
 		time.Sleep(logQueryBackoffDuration)
 	}
-	return nil, fmt.Errorf("QueryLog() failed: %s not found, exhausted retries", logNameRegex)
+	return nil, fmt.Errorf("QueryAllLogs() failed: %s not found, exhausted retries", logNameRegex)
 }
 
 // AssertLogMissing looks in the logging backend for a log matching the given query
 // and returns success if no data is found. To consider possible transient errors
 // while querying the backend we make queryMaxAttemptsLogMissing query attempts.
 func AssertLogMissing(ctx context.Context, logger *log.Logger, vm *VM, logNameRegex string, window time.Duration, query string) error {
 	for attempt := 1; attempt <= queryMaxAttemptsLogMissing; attempt++ {
-		found, _, err := hasMatchingLog(ctx, logger, vm, logNameRegex, window, query)
+		matchingLogs, err := findMatchingLogs(ctx, logger, vm, logNameRegex, window, query)
 		if err == nil {
-			if found {
+			if len(matchingLogs) > 0 {
 				return fmt.Errorf("AssertLogMissing(log=%q): %v failed: unexpectedly found data for log", query, err)
 			}
 			// Success
 			return nil
 		}
-		logger.Printf("Query returned found=%v, err=%v, attempt=%d", found, err, attempt)
+		logger.Printf("Query returned matchingLogs=%v, err=%v, attempt=%d", matchingLogs, err, attempt)
 		if err != nil && !shouldRetryHasMatchingLog(err) {
 			// A non-retryable error.
 			return fmt.Errorf("AssertLogMissing() failed: %v", err)