Always check if metadata.json exists, if not - create it.

2 files changed, 40 insertions, 23 deletions

diff --git a/node-maintainer/src/main/java/com/yahoo/vespa/hosted/node/maintainer/CoredumpHandler.java b/node-maintainer/src/main/java/com/yahoo/vespa/hosted/node/maintainer/CoredumpHandler.java
index cfef8da6732..c14667fb89c 100644
--- a/node-maintainer/src/main/java/com/yahoo/vespa/hosted/node/maintainer/CoredumpHandler.java
+++ b/node-maintainer/src/main/java/com/yahoo/vespa/hosted/node/maintainer/CoredumpHandler.java
@@ -82,12 +82,7 @@ public class CoredumpHandler {
                 .filter(path -> path.toFile().isFile() && ! path.getFileName().toString().startsWith("."))
                 .forEach(coredumpPath -> {
                     try {
-                        coredumpPath.toFile().setReadable(true, false);
-                        coredumpPath = startProcessing(coredumpPath, processingCoredumpsPath);
-
-                        Path metadataPath = coredumpPath.getParent().resolve(METADATA_FILE_NAME);
-                        Map<String, Object> metadata = collectMetadata(coredumpPath, nodeAttributes);
-                        writeMetadata(metadataPath, metadata);
+                        startProcessing(coredumpPath, processingCoredumpsPath);
                     } catch (Throwable e) {
                         logger.log(Level.WARNING, "Failed to process coredump " + coredumpPath, e);
                     }
@@ -103,7 +98,8 @@ public class CoredumpHandler {
                 .filter(path -> path.toFile().isDirectory())
                 .forEach(coredumpDirectory -> {
                     try {
-                        report(coredumpDirectory);
+                        String metadata = collectMetadata(coredumpDirectory, nodeAttributes);
+                        report(coredumpDirectory, metadata);
                         finishProcessing(coredumpDirectory);
                     } catch (Throwable e) {
                         logger.log(Level.WARNING, "Failed to report coredump " + coredumpDirectory, e);
@@ -112,28 +108,35 @@ public class CoredumpHandler {
     }
 
     Path startProcessing(Path coredumpPath, Path processingCoredumpsPath) throws IOException {
+        // Make coredump readable
+        coredumpPath.toFile().setReadable(true, false);
+
+        // Create new directory for this coredump and move it into it
         Path folder = processingCoredumpsPath.resolve(UUID.randomUUID().toString());
         folder.toFile().mkdirs();
         return Files.move(coredumpPath, folder.resolve(coredumpPath.getFileName()));
     }
 
-    private Map<String, Object> collectMetadata(Path coredumpPath, Map<String, Object> nodeAttributes) {
-        Map<String, Object> metadata = coreCollector.collect(coredumpPath, yinstStatePath);
-        metadata.putAll(nodeAttributes);
+    String collectMetadata(Path coredumpPath, Map<String, Object> nodeAttributes) throws IOException {
+        Path metadataPath = coredumpPath.resolve(METADATA_FILE_NAME);
+        if (!Files.exists(metadataPath)) {
+            Map<String, Object> metadata = coreCollector.collect(coredumpPath, yinstStatePath);
+            metadata.putAll(nodeAttributes);
 
-        Map<String, Object> fields = new HashMap<>();
-        fields.put("fields", metadata);
-        return fields;
-    }
+            Map<String, Object> fields = new HashMap<>();
+            fields.put("fields", metadata);
 
-    private void writeMetadata(Path metadataPath, Map<String, Object> metadata) throws IOException {
-        Files.write(metadataPath, objectMapper.writeValueAsString(metadata).getBytes());
+            String metadataFields = objectMapper.writeValueAsString(fields);
+            Files.write(metadataPath, metadataFields.getBytes());
+            return metadataFields;
+        } else {
+            return new String(Files.readAllBytes(metadataPath));
+        }
     }
 
-    void report(Path coredumpDirectory) throws IOException {
+    void report(Path coredumpDirectory, String metadata) throws IOException {
         // Use core dump UUID as document ID
         String documentId = coredumpDirectory.getFileName().toString();
-        String metadata = new String(Files.readAllBytes(coredumpDirectory.resolve(METADATA_FILE_NAME)));
 
         HttpPost post = new HttpPost(FEED_ENDPOINT + "/" + documentId);
         post.setHeader(HttpHeaders.CONTENT_TYPE, "application/json");
diff --git a/node-maintainer/src/test/java/com/yahoo/vespa/hosted/node/maintainer/CoredumpHandlerTest.java b/node-maintainer/src/test/java/com/yahoo/vespa/hosted/node/maintainer/CoredumpHandlerTest.java
index 4bd66709ff0..c33f644138a 100644
--- a/node-maintainer/src/test/java/com/yahoo/vespa/hosted/node/maintainer/CoredumpHandlerTest.java
+++ b/node-maintainer/src/test/java/com/yahoo/vespa/hosted/node/maintainer/CoredumpHandlerTest.java
@@ -34,6 +34,7 @@ import static org.junit.Assert.assertEquals;
 import static org.mockito.Matchers.any;
 import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.verifyZeroInteractions;
 import static org.mockito.Mockito.when;
 
 /**
@@ -93,7 +94,7 @@ public class CoredumpHandlerTest {
     public void startProcessingTest() throws IOException {
         Path coredumpPath = createCoredump("core.dump");
         Path processingPath = crashPath.resolve("processing_dir");
-        coredumpHandler.startProcessing(coredumpPath, crashPath.resolve("processing_dir"));
+        coredumpHandler.startProcessing(coredumpPath, processingPath);
 
         // Contents of 'crash' should be only the 'processing' directory
         assertFolderContents(crashPath, processingPath.getFileName().toString());
@@ -111,12 +112,25 @@ public class CoredumpHandlerTest {
         when(coreCollector.collect(any(), any())).thenReturn(metadata);
         createCoredump("core.dump");
         Path processingPath = coredumpHandler.processCoredumps();
+        Path processingCoredumpPath = Files.list(processingPath).findFirst().orElseThrow(() ->
+                new RuntimeException("Expected to find directory with coredump in processing dir"));
 
-        // Inside 'processing' directory, there should be a new directory containing 'metadata.json' file
-        List<Path> processedCoredumps = Files.list(processingPath).collect(Collectors.toList());
+        // Inside 'processing' directory, there should be a new directory containing 'core.dump' file
+        String returnedMetadata = coredumpHandler.collectMetadata(processingCoredumpPath, attributes);
         String metadataFileContents = new String(Files.readAllBytes(
-                processedCoredumps.get(0).resolve(CoredumpHandler.METADATA_FILE_NAME)));
+                processingCoredumpPath.resolve(CoredumpHandler.METADATA_FILE_NAME)));
         assertEquals(expectedMetadataFileContents, metadataFileContents);
+        assertEquals(expectedMetadataFileContents, returnedMetadata);
+    }
+
+    @Test
+    public void coredumpMetadataReadIfExistsTest() throws IOException, InterruptedException {
+        final String documentId = "UIDD-ABCD-EFGH";
+        Path metadataPath = createProcessedCoredump(documentId);
+
+        verifyZeroInteractions(coreCollector);
+        String returnedMetadata = coredumpHandler.collectMetadata(metadataPath.getParent(), attributes);
+        assertEquals(expectedMetadataFileContents, returnedMetadata);
     }
 
     @Test
@@ -125,7 +139,7 @@ public class CoredumpHandlerTest {
         Path coredumpPath = createProcessedCoredump(documentId);
 
         setNextHttpResponse(200, Optional.empty());
-        coredumpHandler.report(coredumpPath.getParent());
+        coredumpHandler.report(coredumpPath.getParent(), expectedMetadataFileContents);
         validateNextHttpPost(documentId, expectedMetadataFileContents);
     }