1. import java.util.ArrayList;
  2. import java.util.List;
  3. import java.util.Map;
  4. import java.util.HashMap;
  6. public class LogStreamValidator {
  8. /**
  9. * Validates log streams based on provided conditions with retry logic.
  10. *
  11. * @param logStreams A list of log stream data (simulated).
  12. * @param conditions A list of validation conditions. Each condition is a Map containing
  13. * the field to check and the expected value.
  14. * @param maxRetries The maximum number of retry attempts for each log stream.
  15. * @return A list of validation results. Each result indicates whether a log stream passed or failed
  16. * and the reason for failure (if any).
  17. */
  18. public static List<ValidationResult> validateLogStreams(List<String> logStreams, List<Map<String, String>> conditions, int maxRetries) {
  19. List<ValidationResult> results = new ArrayList<>();
  21. for (String logStream : logStreams) {
  22. int retryCount = 0;
  23. boolean isValid = false;
  24. String errorMessage = null;
  26. while (!isValid && retryCount < maxRetries) {
  27. try {
  28. if (validateLogStream(logStream, conditions)) {
  29. isValid = true;
  30. } else {
  31. errorMessage = "Validation failed on attempt " + (retryCount + 1);
  32. }
  33. } catch (Exception e) {
  34. errorMessage = "Exception during validation: " + e.getMessage();
  35. }
  36. retryCount++;
  37. }
  39. results.add(new ValidationResult(logStream, isValid, errorMessage));
  40. }
  42. return results;
  43. }
  45. private static boolean validateLogStream(String logStream, List<Map<String, String>> conditions) throws Exception {
  46. // Simulate log stream processing and condition validation
  47. for (Map<String, String> condition : conditions) {
  48. String field = condition.keySet().iterator().next(); // Get the field name
  49. String expectedValue = condition.get(field);
  51. String actualValue = extractFieldValue(logStream, field);
  53. if (actualValue == null) {
  54. throw new IllegalArgumentException("Field '" + field + "' not found in log stream.");
  55. }
  57. if (!actualValue.equals(expectedValue)) {
  58. throw new IllegalArgumentException("Field '" + field + "' has incorrect value. Expected: '" + expectedValue + "', Actual: '" + actualValue + "'.");
  59. }
  60. }
  61. return true;
  62. }
  64. private static String extractFieldValue(String logStream, String field) {
  65. // Simulate extracting the value of a field from the log stream.
  66. // This is a placeholder. In a real application, this would involve
  67. // parsing the log stream.
  68. if (logStream.contains(field)) {
  69. return logStream.substring(logStream.indexOf(field) + field.length());
  70. }
  71. return null;
  72. }
  74. public static class ValidationResult {
  75. private final String logStream;
  76. private final boolean isValid;
  77. private final String errorMessage;
  79. public ValidationResult(String logStream, boolean isValid, String errorMessage) {
  80. this.logStream = logStream;
  81. this.isValid = isValid;
  82. this.errorMessage = errorMessage;
  83. }
  85. public String getLogStream() {
  86. return logStream;
  87. }
  89. public boolean isIsValid() {
  90. return isValid;
  91. }
  93. public String getErrorMessage() {
  94. return errorMessage;
  95. }
  96. }
  99. public static void main(String[] args) {
  100. List<String> logStreams = new ArrayList<>();
  101. logStreams.add("timestamp=2024-10-27T10:00:00, status=OK");
  102. logStreams.add("timestamp=2024-10-27T10:00:01, status=ERROR");
  103. logStreams.add("timestamp=2024-10-27T10:00:02, status=OK");
  105. List<Map<String, String>> conditions = new ArrayList<>();
  106. Map<String, String> condition1 = new HashMap<>();
  107. condition1.put("status", "OK");
  108. conditions.add(condition1);
  110. Map<String, String> condition2 = new HashMap<>();
  111. condition2.put("timestamp", "2024-10-27

Add your comment