Interns/verification fix (#3039)

* Now stores netInfo also if ping6 did not work

* Added information to README

* Changed disk benchmark command to use conv = fdatasync

* Diskretriever now sums up all sizes from df to get disk size

* Extracted test JSON strings to separate files

* Disk retriever now ignores RAM and first row

* Changed mock input for disk size retriever test

* using pvdisplay to retrieve disk size

* Changed to not assume IPv4 address exist in node repo

* DiskRetriever now handles multiple disks by adding them to get tot disk size

* IPAddressVerifier now verifies both IP addresses against hostname reported by node repo JSON

* NetRetriever now throws exceptions in a consistent way

* MemoryRetriver throws exception similar to other retrievers

* More detailed logging in case of exception in DiskRetriever

* Changed logging depending on exception type in NetRetriever

* Now compares ipv6 connectivity with node repo

* attempt to make Pogo seperate out verifications with errors

* The complete match metric is now also dependent on ping response

* Added check making sure spec verification is not run on virtual machines

10 files changed, 243 insertions, 146 deletions

diff --git a/node-maintainer/src/main/java/com/yahoo/vespa/hosted/node/verification/spec/HardwareNodeComparator.java b/node-maintainer/src/main/java/com/yahoo/vespa/hosted/node/verification/spec/HardwareNodeComparator.java
index a61ba11ff22..8a635e2e3ec 100644
--- a/node-maintainer/src/main/java/com/yahoo/vespa/hosted/node/verification/spec/HardwareNodeComparator.java
+++ b/node-maintainer/src/main/java/com/yahoo/vespa/hosted/node/verification/spec/HardwareNodeComparator.java
@@ -87,8 +87,10 @@ public class HardwareNodeComparator {
             specReportMetrics.setExpectedInterfaceSpeed(expectedInterfaceSpeed);
             specReportMetrics.setActualInterfaceSpeed(actualInterfaceSpeed);
         }
-        if (!actualHardware.isIpv6Connection()) {
-            specReportMetrics.setActualIpv6Connection(false);
+
+        if (node.isIpv6Connection() != actualHardware.isIpv6Connection()) {
+            specReportMetrics.setActualIpv6Connection(actualHardware.isIpv6Connection());
+            specReportMetrics.setExpectedIpv6Connection(node.isIpv6Connection());
         }
     }
 
@@ -106,13 +108,13 @@ public class HardwareNodeComparator {
 
     private static boolean compareNetInterface(HardwareInfo node, HardwareInfo actualHardware, SpecReportDimensions specReportDimensions) {
         boolean equalNetInterfaceSpeed = insideThreshold(node.getInterfaceSpeedMbs(), actualHardware.getInterfaceSpeedMbs());
-        boolean equalIpv6 = node.getIpv6Interface() == actualHardware.getIpv6Interface();
-        boolean equalIpv4 = node.getIpv4Interface() == actualHardware.getIpv4Interface();
+        boolean equalIpv6Interface = node.getIpv6Interface() == actualHardware.getIpv6Interface();
+        boolean equalIpv4Interface = node.getIpv4Interface() == actualHardware.getIpv4Interface();
+        boolean equalIpv6Connection = node.isIpv6Connection() == actualHardware.isIpv6Connection();
         specReportDimensions.setNetInterfaceSpeedMatch(equalNetInterfaceSpeed);
-        specReportDimensions.setIpv6Match(equalIpv6);
-        specReportDimensions.setIpv4Match(equalIpv4);
-        return equalNetInterfaceSpeed && equalIpv6 && equalIpv4;
-
+        specReportDimensions.setIpv6Match(equalIpv6Interface);
+        specReportDimensions.setIpv4Match(equalIpv4Interface);
+        return equalNetInterfaceSpeed && equalIpv6Interface && equalIpv4Interface && equalIpv6Connection;
     }
 
     private static boolean compareDisk(HardwareInfo node, HardwareInfo actualHardware, SpecReportDimensions specReportDimensions) {
diff --git a/node-maintainer/src/main/java/com/yahoo/vespa/hosted/node/verification/spec/HostURLGenerator.java b/node-maintainer/src/main/java/com/yahoo/vespa/hosted/node/verification/spec/HostURLGenerator.java
index 2fb81d4db63..157f618761d 100644
--- a/node-maintainer/src/main/java/com/yahoo/vespa/hosted/node/verification/spec/HostURLGenerator.java
+++ b/node-maintainer/src/main/java/com/yahoo/vespa/hosted/node/verification/spec/HostURLGenerator.java
@@ -31,11 +31,19 @@ public class HostURLGenerator {
         return nodeInfoUrls;
     }
 
-    protected static URL buildNodeInfoURL(String configServerHostName, String nodeHostName) throws MalformedURLException {
-        if (configServerHostName.matches(PROTOCOL_REGEX)) {
-            return new URL(configServerHostName + NODE_HOSTNAME_PREFIX + nodeHostName);
-        }
-        return new URL(HTTP + configServerHostName + PORT_NUMBER + NODE_HOSTNAME_PREFIX + nodeHostName);
+    protected static String[] getConfigServerHostNames(CommandExecutor commandExecutor) throws IOException {
+        ArrayList<String> output = commandExecutor.executeCommand(CONFIG_SERVER_HOST_NAME_COMMAND);
+        if (output.size() != 1)
+            throw new IOException("Expected one line return from the command: " + CONFIG_SERVER_HOST_NAME_COMMAND);
+        String[] configServerHostNames = parseOutHostNames(output.get(0));
+        return configServerHostNames;
+    }
+
+    private static String[] parseOutHostNames(String output) throws IOException {
+        String[] outputSplit = output.trim().split(PARSE_OUT_HOSTNAMES_REGEX);
+        if (outputSplit.length != 2) throw new IOException("Expected config server host names to have index 1");
+        String[] configServerHostNames = outputSplit[1].split(PARSE_ALL_HOSTNAMES_REGEX);
+        return configServerHostNames;
     }
 
     protected static String generateNodeHostName(CommandExecutor commandExecutor) throws IOException {
@@ -51,19 +59,11 @@ public class HostURLGenerator {
         throw new IOException("Unexpected output from \"hostname\" command.");
     }
 
-    protected static String[] getConfigServerHostNames(CommandExecutor commandExecutor) throws IOException {
-        ArrayList<String> output = commandExecutor.executeCommand(CONFIG_SERVER_HOST_NAME_COMMAND);
-        if (output.size() != 1)
-            throw new IOException("Expected one line return from the command: " + CONFIG_SERVER_HOST_NAME_COMMAND);
-        String[] configServerHostNames = parseOutHostNames(output.get(0));
-        return configServerHostNames;
-    }
-
-    private static String[] parseOutHostNames(String output) throws IOException {
-        String[] outputSplit = output.trim().split(PARSE_OUT_HOSTNAMES_REGEX);
-        if (outputSplit.length != 2) throw new IOException("Expected config server hsot names to have index 1");
-        String[] configServerHostNames = outputSplit[1].split(PARSE_ALL_HOSTNAMES_REGEX);
-        return configServerHostNames;
+    protected static URL buildNodeInfoURL(String configServerHostName, String nodeHostName) throws MalformedURLException {
+        if (configServerHostName.matches(PROTOCOL_REGEX)) {
+            return new URL(configServerHostName + NODE_HOSTNAME_PREFIX + nodeHostName);
+        }
+        return new URL(HTTP + configServerHostName + PORT_NUMBER + NODE_HOSTNAME_PREFIX + nodeHostName);
     }
 
 }
diff --git a/node-maintainer/src/main/java/com/yahoo/vespa/hosted/node/verification/spec/SpecVerifier.java b/node-maintainer/src/main/java/com/yahoo/vespa/hosted/node/verification/spec/SpecVerifier.java
index 08d5d1b1d74..c2b295684a8 100644
--- a/node-maintainer/src/main/java/com/yahoo/vespa/hosted/node/verification/spec/SpecVerifier.java
+++ b/node-maintainer/src/main/java/com/yahoo/vespa/hosted/node/verification/spec/SpecVerifier.java
@@ -14,6 +14,7 @@ import com.yahoo.vespa.hosted.node.verification.spec.yamasreport.YamasSpecReport
 import java.io.IOException;
 import java.net.URL;
 import java.util.ArrayList;
+import java.util.logging.Level;
 import java.util.logging.Logger;
 
 /**
@@ -24,9 +25,14 @@ import java.util.logging.Logger;
 public class SpecVerifier {
 
     private static final Logger logger = Logger.getLogger(SpecVerifier.class.getName());
+    private static final String VIRTUAL_ENVIRONMENT= "VIRTUAL_MACHINE";
 
     public static boolean verifySpec(CommandExecutor commandExecutor) throws IOException {
         NodeRepoJsonModel nodeRepoJsonModel = getNodeRepositoryJSON(commandExecutor);
+        if (nodeRepoJsonModel.getEnvironment().equals(VIRTUAL_ENVIRONMENT)) {
+            logger.log(Level.INFO, "Node is virtual machine - No need for verification");
+            return true;
+        }
         HardwareInfo actualHardware = HardwareInfoRetriever.retrieve(commandExecutor);
         YamasSpecReport yamasSpecReport = makeYamasSpecReport(actualHardware, nodeRepoJsonModel);
         printResults(yamasSpecReport);
@@ -58,7 +64,9 @@ public class SpecVerifier {
 
     public static void main(String[] args) throws IOException {
         CommandExecutor commandExecutor = new CommandExecutor();
-        SpecVerifier.verifySpec(commandExecutor);
+        if (!SpecVerifier.verifySpec(commandExecutor)){
+            System.exit(2);
+        }
     }
 
 }
diff --git a/node-maintainer/src/main/java/com/yahoo/vespa/hosted/node/verification/spec/noderepo/IPAddressVerifier.java b/node-maintainer/src/main/java/com/yahoo/vespa/hosted/node/verification/spec/noderepo/IPAddressVerifier.java
index 690a57ba242..9333a1e979a 100644
--- a/node-maintainer/src/main/java/com/yahoo/vespa/hosted/node/verification/spec/noderepo/IPAddressVerifier.java
+++ b/node-maintainer/src/main/java/com/yahoo/vespa/hosted/node/verification/spec/noderepo/IPAddressVerifier.java
@@ -24,16 +24,57 @@ public class IPAddressVerifier {
     private static final Logger logger = Logger.getLogger(IPAddressVerifier.class.getName());
 
     public void reportFaultyIpAddresses(NodeRepoJsonModel nodeRepoJsonModel, YamasSpecReport yamasSpecReport) {
-        String[] faultyIpAddresses = getFaultyIpAddresses(nodeRepoJsonModel.getIpv6Address(), nodeRepoJsonModel.getAdditionalIpAddresses());
+        String[] faultyIpAddresses = getFaultyIpAddresses(nodeRepoJsonModel);
         if (faultyIpAddresses.length > 0) {
             yamasSpecReport.setFaultyIpAddresses(faultyIpAddresses);
         }
     }
 
+    public String[] getFaultyIpAddresses(NodeRepoJsonModel jsonModel) {
+        String expectedHostname = jsonModel.getHostname();
+        ArrayList<String> faultyIpAddresses = new ArrayList<>();
+        if (expectedHostname == null || expectedHostname.equals(""))
+            return new String[0];
+        if (!isValidIpv4(jsonModel.getIpv4Address(), expectedHostname)) {
+            faultyIpAddresses.add(jsonModel.getIpv4Address());
+        }
+        if (!isValidIpv6(jsonModel.getIpv6Address(), expectedHostname)) {
+            faultyIpAddresses.add(jsonModel.getIpv6Address());
+        }
+        return faultyIpAddresses.stream().toArray(String[]::new);
+    }
+
+    private boolean isValidIpv4(String ipv4Address, String expectedHostname) {
+        if (ipv4Address == null) {
+            return true;
+        }
+        String ipv4LookupFormat = convertIpv4ToLookupFormat(ipv4Address);
+        try {
+            String ipv4Hostname = reverseLookUp(ipv4LookupFormat);
+            return ipv4Hostname.equals(expectedHostname);
+        } catch (NamingException e) {
+            logger.log(Level.WARNING, "Could not get IPv4 hostname", e);
+        }
+        return false;
+    }
+
+    private boolean isValidIpv6(String ipv6Address, String expectedHostname) {
+        if (ipv6Address == null) {
+            return true;
+        }
+        String ipv6LookupFormat = convertIpv6ToLookupFormat(ipv6Address);
+        try {
+            String ipv6Hostname = reverseLookUp(ipv6LookupFormat);
+            return ipv6Hostname.equals(expectedHostname);
+        } catch (NamingException e) {
+            logger.log(Level.WARNING, "Could not get IPv6 hostname", e);
+        }
+        return false;
+    }
+
     protected String reverseLookUp(String ipAddress) throws NamingException {
         Hashtable<String, String> env = new Hashtable<>();
         env.put("java.naming.factory.initial", "com.sun.jndi.dns.DnsContextFactory");
-        String ipAddressInLookupFormat = convertToLookupFormat(ipAddress);
         String attributeName = ipAddress;
         DirContext ctx = new InitialDirContext(env);
         Attributes attrs = ctx.getAttributes(attributeName, new String[]{"PTR"});
@@ -41,16 +82,17 @@ public class IPAddressVerifier {
             Attribute attr = ae.next();
             Enumeration<?> vals = attr.getAll();
             if (vals.hasMoreElements()) {
-                return vals.nextElement().toString();
+                String hostname = vals.nextElement().toString();
+                return hostname.substring(0, hostname.length() - 1);
             }
         }
         ctx.close();
         return "";
     }
 
-    protected String convertToLookupFormat(String ipAddress) {
+    protected String convertIpv6ToLookupFormat(String ipAddress) {
         StringBuilder newIpAddress = new StringBuilder();
-        String doubleColonReplacement = "0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.";
+        String doubleColonReplacement = "0.0.0.0.0.0.0.0.0.0.0.0.";
         String domain = "ip6.arpa";
         String[] hextets = ipAddress.split(":");
         for (int i = hextets.length - 1; i >= 0; i--) {
@@ -68,32 +110,15 @@ public class IPAddressVerifier {
         return newIpAddress.toString();
     }
 
-    public String[] getFaultyIpAddresses(String ipAddress, String[] additionalIpAddresses) {
-        if (ipAddress == null || additionalIpAddresses == null || additionalIpAddresses.length == 0)
-            return new String[0];
-        String realHostname;
-        ArrayList<String> faultyIpAddresses = new ArrayList<>();
-        try {
-            realHostname = reverseLookUp(ipAddress);
-        } catch (NamingException e) {
-            logger.log(Level.WARNING, "Unable to look up host name of address " + ipAddress, e);
-            return new String[0];
-        }
-        for (String additionalIpAddress : additionalIpAddresses) {
-            addIfFaultyIpAddress(realHostname, additionalIpAddress, faultyIpAddresses);
-        }
-        return faultyIpAddresses.stream().toArray(String[]::new);
-    }
-
-    private void addIfFaultyIpAddress(String realHostname, String additionalIpAddress, ArrayList<String> faultyIpAddresses) {
-        try {
-            String additionalHostName = reverseLookUp(additionalIpAddress);
-            if (!realHostname.equals(additionalHostName)) {
-                faultyIpAddresses.add(additionalIpAddress);
-            }
-        } catch (NamingException e) {
-            logger.log(Level.WARNING, "Unable to retrieve hostname of additional address: " + additionalIpAddress, e);
+    protected String convertIpv4ToLookupFormat(String ipAddress) {
+        String domain = "in-addr.arpa";
+        String[] octets = ipAddress.split("\\.");
+        StringBuilder convertedIpAddress = new StringBuilder();
+        for (int i = octets.length - 1; i >= 0; i--) {
+            convertedIpAddress.append(octets[i] + ".");
         }
+        convertedIpAddress.append(domain);
+        return convertedIpAddress.toString();
     }
 
 }
diff --git a/node-maintainer/src/main/java/com/yahoo/vespa/hosted/node/verification/spec/noderepo/NodeJsonConverter.java b/node-maintainer/src/main/java/com/yahoo/vespa/hosted/node/verification/spec/noderepo/NodeJsonConverter.java
index dfd2bb011a2..ec078624920 100644
--- a/node-maintainer/src/main/java/com/yahoo/vespa/hosted/node/verification/spec/noderepo/NodeJsonConverter.java
+++ b/node-maintainer/src/main/java/com/yahoo/vespa/hosted/node/verification/spec/noderepo/NodeJsonConverter.java
@@ -9,20 +9,26 @@ import com.yahoo.vespa.hosted.node.verification.spec.retrievers.HardwareInfo;
 public class NodeJsonConverter {
 
     private static void addStandardSpecifications(HardwareInfo nodeRepoHardwareInfo) {
-        nodeRepoHardwareInfo.setIpv4Interface(true);
         nodeRepoHardwareInfo.setInterfaceSpeedMbs(1000);
     }
 
-    protected static void setIpv6AddressConnectivity(NodeRepoJsonModel nodeRepoJsonModel, HardwareInfo nodeRepoHardwareInfo) {
+    protected static void setIpv6Interface(NodeRepoJsonModel nodeRepoJsonModel, HardwareInfo nodeRepoHardwareInfo) {
         if (nodeRepoJsonModel.getIpv6Address() != null) {
             nodeRepoHardwareInfo.setIpv6Interface(true);
         }
     }
 
+    protected static void setIpv4Interface(NodeRepoJsonModel nodeRepoJsonModel, HardwareInfo nodeRepoHardwareInfo) {
+        if (nodeRepoJsonModel.getIpv4Address() != null) {
+            nodeRepoHardwareInfo.setIpv4Interface(true);
+        }
+    }
+
     public static HardwareInfo convertJsonModelToHardwareInfo(NodeRepoJsonModel nodeRepoJsonModel) {
         HardwareInfo nodeRepoHardwareInfo = nodeRepoJsonModel.copyToHardwareInfo();
         addStandardSpecifications(nodeRepoHardwareInfo);
-        setIpv6AddressConnectivity(nodeRepoJsonModel, nodeRepoHardwareInfo);
+        setIpv4Interface(nodeRepoJsonModel, nodeRepoHardwareInfo);
+        setIpv6Interface(nodeRepoJsonModel, nodeRepoHardwareInfo);
         return nodeRepoHardwareInfo;
     }
 
diff --git a/node-maintainer/src/main/java/com/yahoo/vespa/hosted/node/verification/spec/noderepo/NodeRepoJsonModel.java b/node-maintainer/src/main/java/com/yahoo/vespa/hosted/node/verification/spec/noderepo/NodeRepoJsonModel.java
index f946a7343dc..2367d255987 100644
--- a/node-maintainer/src/main/java/com/yahoo/vespa/hosted/node/verification/spec/noderepo/NodeRepoJsonModel.java
+++ b/node-maintainer/src/main/java/com/yahoo/vespa/hosted/node/verification/spec/noderepo/NodeRepoJsonModel.java
@@ -24,6 +24,10 @@ public class NodeRepoJsonModel {
     private String[] ipAddresses;
     @JsonProperty("additionalIpAddresses")
     private String[] additionalIpAddresses;
+    @JsonProperty
+    private String hostname;
+    @JsonProperty
+    private String environment;
 
     public String[] getAdditionalIpAddresses() {
         return additionalIpAddresses;
@@ -35,6 +39,7 @@ public class NodeRepoJsonModel {
         hardwareInfo.setMinDiskAvailableGb(this.minDiskAvailableGb);
         hardwareInfo.setMinCpuCores((int) Math.round(this.minCpuCores));
         hardwareInfo.setDiskType(this.fastDisk ? DiskType.FAST : DiskType.SLOW);
+        hardwareInfo.setIpv6Connection(getIpv6Address() != null);
         return hardwareInfo;
     }
 
@@ -48,6 +53,16 @@ public class NodeRepoJsonModel {
         return null;
     }
 
+    public String getIpv4Address() {
+        String ipv4Regex = "((1?\\d\\d?|2[0-4]\\d|25[0-5])\\.){3}(1?\\d\\d?|2[0-4]\\d|2\u200C\u200B5[0-5])";
+        for (String ipAddress : ipAddresses) {
+            if (ipAddress.matches(ipv4Regex)) {
+                return ipAddress;
+            }
+        }
+        return null;
+    }
+
     public double getMinDiskAvailableGb() {
         return minDiskAvailableGb;
     }
@@ -68,4 +83,12 @@ public class NodeRepoJsonModel {
         return ipAddresses;
     }
 
+    public String getHostname() {
+        return hostname;
+    }
+
+    public String getEnvironment() {
+        return environment;
+    }
+
 }
diff --git a/node-maintainer/src/main/java/com/yahoo/vespa/hosted/node/verification/spec/retrievers/DiskRetriever.java b/node-maintainer/src/main/java/com/yahoo/vespa/hosted/node/verification/spec/retrievers/DiskRetriever.java
index 8fe9e04db30..42d459217a0 100644
--- a/node-maintainer/src/main/java/com/yahoo/vespa/hosted/node/verification/spec/retrievers/DiskRetriever.java
+++ b/node-maintainer/src/main/java/com/yahoo/vespa/hosted/node/verification/spec/retrievers/DiskRetriever.java
@@ -17,15 +17,15 @@ import java.util.logging.Logger;
  */
 public class DiskRetriever implements HardwareRetriever {
     private static final String DISK_CHECK_TYPE = "lsblk -d -o name,rota";
-    private static final String DISK_CHECK_SIZE = "df -BG | grep -v tmpfs | awk '{s+=$2} END {print s-1}'";
+    private static final String DISK_CHECK_SIZE = "sudo pvdisplay --units G | grep 'PV Size'";
     private static final String DISK_NAME = "sda";
     private static final String DISK_TYPE_REGEX_SPLIT = "\\s+";
     private static final int DISK_TYPE_SEARCH_ELEMENT_INDEX = 0;
     private static final int DISK_TYPE_RETURN_ELEMENT_INDEX = 1;
-    private static final String DISK_SIZE_SEARCH_WORD = ".*\\d+.*";
+    private static final String DISK_SIZE_SEARCH_WORD = "Size";
     private static final String DISK_SIZE_REGEX_SPLIT = "\\s+";
-    private static final int DISK_SIZE_SEARCH_ELEMENT_INDEX = 0;
-    private static final int DISK_SIZE_RETURN_ELEMENT_INDEX = 0;
+    private static final int DISK_SIZE_SEARCH_ELEMENT_INDEX = 1;
+    private static final int DISK_SIZE_RETURN_ELEMENT_INDEX = 2;
     private static final Logger logger = Logger.getLogger(DiskRetriever.class.getName());
     private final HardwareInfo hardwareInfo;
     private final CommandExecutor commandExecutor;
@@ -37,37 +37,42 @@ public class DiskRetriever implements HardwareRetriever {
     }
 
     public void updateInfo() {
-        try {
             updateDiskType();
             updateDiskSize();
-        } catch (IOException e) {
-            logger.log(Level.WARNING, "Failed to retrieve disk info", e);
-        }
     }
 
-    protected void updateDiskType() throws IOException {
-        ArrayList<String> commandOutput = commandExecutor.executeCommand(DISK_CHECK_TYPE);
-        ParseResult parseResult = parseDiskType(commandOutput);
-        setDiskType(parseResult);
+    protected void updateDiskType() {
+        try {
+            ArrayList<String> commandOutput = commandExecutor.executeCommand(DISK_CHECK_TYPE);
+            ParseResult parseResult = parseDiskType(commandOutput);
+            setDiskType(parseResult);
+        } catch (IOException e) {
+            logger.log(Level.WARNING, "Failed to retrieve disk type", e);
+        }
     }
 
-    protected void updateDiskSize() throws IOException {
-        ArrayList<String> commandOutput = commandExecutor.executeCommand(DISK_CHECK_SIZE);
-        ParseResult parseResult = parseDiskSize(commandOutput);
-        setDiskSize(parseResult);
+    protected void updateDiskSize() {
+        try {
+            ArrayList<String> commandOutput = commandExecutor.executeCommand(DISK_CHECK_SIZE);
+            ArrayList<ParseResult> parseResult = parseDiskSize(commandOutput);
+            setDiskSize(parseResult);
+        } catch (IOException e) {
+            logger.log(Level.WARNING, "Failed to retrieve disk size", e);
+        }
     }
 
-    protected ParseResult parseDiskType(ArrayList<String> commandOutput) {
+    protected ParseResult parseDiskType(ArrayList<String> commandOutput) throws IOException {
         ArrayList<String> searchWords = new ArrayList<>(Arrays.asList(DISK_NAME));
         ParseInstructions parseInstructions = new ParseInstructions(DISK_TYPE_SEARCH_ELEMENT_INDEX, DISK_TYPE_RETURN_ELEMENT_INDEX, DISK_TYPE_REGEX_SPLIT, searchWords);
-        return OutputParser.parseSingleOutput(parseInstructions, commandOutput);
+        ParseResult parseResult = OutputParser.parseSingleOutput(parseInstructions, commandOutput);
+        if (!parseResult.getSearchWord().equals(DISK_NAME)) {
+            throw new IOException("Parsing for disk type failed");
+        }
+        return parseResult;
     }
 
     protected void setDiskType(ParseResult parseResult) {
         hardwareInfo.setDiskType(DiskType.UNKNOWN);
-        if (!parseResult.getSearchWord().equals(DISK_NAME)) {
-            return;
-        }
         String fastDiskSymbol = "0";
         String nonFastDiskSymbol = "1";
         if (parseResult.getValue().equals(fastDiskSymbol)) {
@@ -77,20 +82,25 @@ public class DiskRetriever implements HardwareRetriever {
         }
     }
 
-    protected ParseResult parseDiskSize(ArrayList<String> commandOutput) {
+    protected ArrayList<ParseResult> parseDiskSize(ArrayList<String> commandOutput) {
         ArrayList<String> searchWords = new ArrayList<>(Arrays.asList(DISK_SIZE_SEARCH_WORD));
         ParseInstructions parseInstructions = new ParseInstructions(DISK_SIZE_SEARCH_ELEMENT_INDEX, DISK_SIZE_RETURN_ELEMENT_INDEX, DISK_SIZE_REGEX_SPLIT, searchWords);
-        return OutputParser.parseSingleOutput(parseInstructions, commandOutput);
+        return OutputParser.parseOutput(parseInstructions, commandOutput);
     }
 
-    protected void setDiskSize(ParseResult parseResult) {
-        try {
-            String sizeValue = parseResult.getValue().replaceAll("[^\\d.]", "");
-            double diskSize = Double.parseDouble(sizeValue);
-            hardwareInfo.setMinDiskAvailableGb(diskSize);
-        } catch (NumberFormatException | NullPointerException e) {
-            return;
-        }
+   protected void setDiskSize(ArrayList<ParseResult> parseResults) {
+       double diskSize = 0;
+       try {
+           for (ParseResult parseResult : parseResults) {
+               String sizeValue = parseResult.getValue().replaceAll("[^\\d.]", "");
+               diskSize += Double.parseDouble(sizeValue);
+           }
+       } catch (NumberFormatException | NullPointerException e) {
+           logger.log(Level.WARNING, "Parse results contained an invalid PV size - ", parseResults);
+       }
+       finally {
+           hardwareInfo.setMinDiskAvailableGb(diskSize);
+       }
     }
 
 }
\ No newline at end of file
diff --git a/node-maintainer/src/main/java/com/yahoo/vespa/hosted/node/verification/spec/retrievers/MemoryRetriever.java b/node-maintainer/src/main/java/com/yahoo/vespa/hosted/node/verification/spec/retrievers/MemoryRetriever.java
index 3cb2b1059ce..da7e82aefb7 100644
--- a/node-maintainer/src/main/java/com/yahoo/vespa/hosted/node/verification/spec/retrievers/MemoryRetriever.java
+++ b/node-maintainer/src/main/java/com/yahoo/vespa/hosted/node/verification/spec/retrievers/MemoryRetriever.java
@@ -17,10 +17,10 @@ import java.util.logging.Logger;
 public class MemoryRetriever implements HardwareRetriever {
 
     private static final String MEMORY_INFO_COMMAND = "cat /proc/meminfo";
-    private static final String searchWord = "MemTotal";
-    private static final String regexSplit = ":\\s";
-    private static final int searchElementIndex = 0;
-    private static final int returnElementIndex = 1;
+    private static final String SEARCH_WORD = "MemTotal";
+    private static final String REGEX_SPLIT = ":\\s";
+    private static final int SEARCH_ELEMENT_INDEX = 0;
+    private static final int RETURN_ELEMENT_INDEX = 1;
     private static final Logger logger = Logger.getLogger(MemoryRetriever.class.getName());
     private final HardwareInfo hardwareInfo;
     private final CommandExecutor commandExecutor;
@@ -37,14 +37,17 @@ public class MemoryRetriever implements HardwareRetriever {
             ParseResult parseResult = parseMemInfoFile(commandOutput);
             updateMemoryInfo(parseResult);
         } catch (IOException e) {
-            logger.log(Level.WARNING, "Failed to retrieve memory info", e);
+            logger.log(Level.WARNING, "Failed to retrieve memory info. ", e);
         }
     }
 
-    protected ParseResult parseMemInfoFile(ArrayList<String> commandOutput) {
-        ArrayList<String> searchWords = new ArrayList<>(Arrays.asList(searchWord));
-        ParseInstructions parseInstructions = new ParseInstructions(searchElementIndex, returnElementIndex, regexSplit, searchWords);
+    protected ParseResult parseMemInfoFile(ArrayList<String> commandOutput) throws IOException {
+        ArrayList<String> searchWords = new ArrayList<>(Arrays.asList(SEARCH_WORD));
+        ParseInstructions parseInstructions = new ParseInstructions(SEARCH_ELEMENT_INDEX, RETURN_ELEMENT_INDEX, REGEX_SPLIT, searchWords);
         ParseResult parseResult = OutputParser.parseSingleOutput(parseInstructions, commandOutput);
+        if (!parseResult.getSearchWord().matches(SEARCH_WORD)){
+            throw new IOException("Failed to parse memory info file.");
+        }
         return parseResult;
     }
 
diff --git a/node-maintainer/src/main/java/com/yahoo/vespa/hosted/node/verification/spec/retrievers/NetRetriever.java b/node-maintainer/src/main/java/com/yahoo/vespa/hosted/node/verification/spec/retrievers/NetRetriever.java
index 0170d79b22d..c3ffd9adb6f 100644
--- a/node-maintainer/src/main/java/com/yahoo/vespa/hosted/node/verification/spec/retrievers/NetRetriever.java
+++ b/node-maintainer/src/main/java/com/yahoo/vespa/hosted/node/verification/spec/retrievers/NetRetriever.java
@@ -4,6 +4,7 @@ import com.yahoo.vespa.hosted.node.verification.commons.CommandExecutor;
 import com.yahoo.vespa.hosted.node.verification.commons.OutputParser;
 import com.yahoo.vespa.hosted.node.verification.commons.ParseInstructions;
 import com.yahoo.vespa.hosted.node.verification.commons.ParseResult;
+import org.apache.commons.exec.ExecuteException;
 
 import java.io.IOException;
 import java.util.ArrayList;
@@ -45,37 +46,24 @@ public class NetRetriever implements HardwareRetriever {
     }
 
     public void updateInfo() {
+        ArrayList<ParseResult> parseResults = findInterface();
+        findInterfaceSpeed(parseResults);
+        testPingResponse(parseResults);
+        updateHardwareInfoWithNet(parseResults);
+    }
+
+    protected ArrayList<ParseResult> findInterface() {
         ArrayList<ParseResult> parseResults = new ArrayList<>();
         try {
-            parseResults = findInterface();
-            findInterfaceSpeed(parseResults);
-            testPingResponse(parseResults);
+            ArrayList<String> commandOutput = commandExecutor.executeCommand(NET_FIND_INTERFACE);
+            parseResults = parseNetInterface(commandOutput);
+
         } catch (IOException e) {
-            logger.log(Level.WARNING, "Failed to retrieve net info", e);
+            logger.log(Level.WARNING, "Failed to retrieve net interface. ", e);
         }
-        finally {
-            updateHardwareInfoWithNet(parseResults);
-        }
-    }
-
-    protected ArrayList<ParseResult> findInterface() throws IOException {
-        ArrayList<String> commandOutput = commandExecutor.executeCommand(NET_FIND_INTERFACE);
-        ArrayList<ParseResult> parseResults = parseNetInterface(commandOutput);
         return parseResults;
     }
 
-    protected void findInterfaceSpeed(ArrayList<ParseResult> parseResults) throws IOException {
-        String interfaceName = findInterfaceName(parseResults);
-        String command = NET_CHECK_INTERFACE_SPEED + " " + interfaceName;
-        ArrayList<String> commandOutput = commandExecutor.executeCommand(command);
-        parseResults.add(parseInterfaceSpeed(commandOutput));
-    }
-
-    protected void testPingResponse(ArrayList<ParseResult> parseResults) throws IOException {
-        ArrayList<String> commandOutput = commandExecutor.executeCommand(PING_NET_COMMAND);
-        parseResults.add(parsePingResponse(commandOutput));
-    }
-
     protected ArrayList<ParseResult> parseNetInterface(ArrayList<String> commandOutput) {
         ArrayList<String> searchWords = new ArrayList<>(Arrays.asList(SEARCH_WORD_INTERFACE_IP4, SEARCH_WORD_INTERFACE_IPV6, SEARCH_WORD_INTERFACE_NAME));
         ParseInstructions parseInstructions = new ParseInstructions(INTERFACE_NAME_SEARCH_ELEMENT_INDEX, INTERFACE_NAME_RETURN_ELEMENT_INDEX, INTERFACE_NAME_REGEX_SPLIT, searchWords);
@@ -85,19 +73,16 @@ public class NetRetriever implements HardwareRetriever {
         return parseResults;
     }
 
-    protected ParseResult parseInterfaceSpeed(ArrayList<String> commandOutput) {
-        ArrayList<String> searchWords = new ArrayList<>(Arrays.asList(SEARCH_WORD_INTERFACE_SPEED));
-        ParseInstructions parseInstructions = new ParseInstructions(INTERFACE_SPEED_SEARCH_ELEMENT_INDEX, INTERFACE_SPEED_RETURN_ELEMENT_INDEX, INTERFACE_SPEED_REGEX_SPLIT, searchWords);
-        ParseResult parseResult = OutputParser.parseSingleOutput(parseInstructions, commandOutput);
-        return parseResult;
-    }
-
-    protected ParseResult parsePingResponse(ArrayList<String> commandOutput) {
-        ArrayList<String> searchWords = new ArrayList<>(Arrays.asList(PING_SEARCH_WORD));
-        ParseInstructions parseInstructions = new ParseInstructions(PING_SEARCH_ELEMENT_INDEX, PING_RETURN_ELEMENT_INDEX, PING_SPLIT_REGEX_STRING, searchWords);
-        ParseResult parseResult = OutputParser.parseSingleOutput(parseInstructions, commandOutput);
-        parseResult = parseResult.getSearchWord().equals(PING_SEARCH_WORD) ? parseResult : new ParseResult(PING_SEARCH_WORD, "invalid");
-        return parseResult;
+    protected void findInterfaceSpeed(ArrayList<ParseResult> parseResults){
+        try {
+            String interfaceName = findInterfaceName(parseResults);
+            String command = NET_CHECK_INTERFACE_SPEED + " " + interfaceName;
+            ArrayList<String> commandOutput = commandExecutor.executeCommand(command);
+            ParseResult parseResult = parseInterfaceSpeed(commandOutput);
+            parseResults.add(parseResult);
+        } catch (IOException e) {
+            logger.log(Level.WARNING, "Failed to retrieve interface speed. ", e);
+        }
     }
 
     protected String findInterfaceName(ArrayList<ParseResult> parseResults) {
@@ -108,8 +93,36 @@ public class NetRetriever implements HardwareRetriever {
         return "";
     }
 
-    protected double convertInterfaceSpeed(String speed) {
-        return Double.parseDouble(speed.replaceAll("[^\\d.]", ""));
+    protected ParseResult parseInterfaceSpeed(ArrayList<String> commandOutput) throws IOException {
+        ArrayList<String> searchWords = new ArrayList<>(Arrays.asList(SEARCH_WORD_INTERFACE_SPEED));
+        ParseInstructions parseInstructions = new ParseInstructions(INTERFACE_SPEED_SEARCH_ELEMENT_INDEX, INTERFACE_SPEED_RETURN_ELEMENT_INDEX, INTERFACE_SPEED_REGEX_SPLIT, searchWords);
+        ParseResult parseResult = OutputParser.parseSingleOutput(parseInstructions, commandOutput);
+        if (!parseResult.getSearchWord().matches(SEARCH_WORD_INTERFACE_SPEED)) {
+            throw new IOException("Failed to parse interface speed output.");
+        }
+        return parseResult;
+    }
+
+    protected void testPingResponse(ArrayList<ParseResult> parseResults) {
+        try {
+            ArrayList<String> commandOutput = commandExecutor.executeCommand(PING_NET_COMMAND);
+            parseResults.add(parsePingResponse(commandOutput));
+        }
+        catch (ExecuteException e) {
+            logger.log(Level.WARNING, "Failed to execute ping6");
+        } catch (IOException e) {
+            logger.log(Level.WARNING, e.getMessage());
+        }
+    }
+
+    protected ParseResult parsePingResponse(ArrayList<String> commandOutput) throws IOException {
+        ArrayList<String> searchWords = new ArrayList<>(Arrays.asList(PING_SEARCH_WORD));
+        ParseInstructions parseInstructions = new ParseInstructions(PING_SEARCH_ELEMENT_INDEX, PING_RETURN_ELEMENT_INDEX, PING_SPLIT_REGEX_STRING, searchWords);
+        ParseResult parseResult = OutputParser.parseSingleOutput(parseInstructions, commandOutput);
+        if (!parseResult.getSearchWord().matches(PING_SEARCH_WORD)) {
+            throw new IOException("Failed to parse ping output.");
+        }
+        return parseResult;
     }
 
     protected void updateHardwareInfoWithNet(ArrayList<ParseResult> parseResults) {
@@ -132,19 +145,21 @@ public class NetRetriever implements HardwareRetriever {
                     break;
                 default:
                     if (parseResult.getSearchWord().matches(SEARCH_WORD_INTERFACE_NAME)) break;
-                    throw new RuntimeException("Invalid ParseResult search word " + parseResult.getSearchWord());
+                    throw new RuntimeException("Invalid ParseResult search word: " + parseResult.getSearchWord());
             }
         }
     }
 
+    protected double convertInterfaceSpeed(String speed) {
+        return Double.parseDouble(speed.replaceAll("[^\\d.]", ""));
+    }
+
     protected void setIpv6Connectivity(ParseResult parseResult) {
-        if (parseResult.getSearchWord().equals(PING_SEARCH_WORD)) {
-            String pingResponse = parseResult.getValue();
-            String packetLoss = pingResponse.replaceAll("[^\\d.]", "");
-            if (packetLoss.equals("")) return;
-            if (Double.parseDouble(packetLoss) > 99) return;
-            hardwareInfo.setIpv6Connection(true);
-        }
+        String pingResponse = parseResult.getValue();
+        String packetLoss = pingResponse.replaceAll("[^\\d.]", "");
+        if (packetLoss.equals("")) return;
+        if (Double.parseDouble(packetLoss) > 99) return;
+        hardwareInfo.setIpv6Connection(true);
     }
 
 }
diff --git a/node-maintainer/src/main/java/com/yahoo/vespa/hosted/node/verification/spec/yamasreport/SpecReportMetrics.java b/node-maintainer/src/main/java/com/yahoo/vespa/hosted/node/verification/spec/yamasreport/SpecReportMetrics.java
index d835a1b29d3..23ddba32d5c 100644
--- a/node-maintainer/src/main/java/com/yahoo/vespa/hosted/node/verification/spec/yamasreport/SpecReportMetrics.java
+++ b/node-maintainer/src/main/java/com/yahoo/vespa/hosted/node/verification/spec/yamasreport/SpecReportMetrics.java
@@ -36,11 +36,16 @@ public class SpecReportMetrics {
     private String[] faultyIpAddresses;
     @JsonProperty
     private Boolean actualIpv6Connection;
+    @JsonProperty
+    private Boolean expectedIpv6Connection;
 
     public void setActualIpv6Connection(boolean actualIpv6Connection) {
         this.actualIpv6Connection = actualIpv6Connection;
     }
 
+    public void setExpectedIpv6Connection(Boolean expectedIpv6Connection) {
+        this.expectedIpv6Connection = expectedIpv6Connection;
+    }
 
     public void setMatch(boolean match) {
         this.match = match;