docs: public static void doMetaCheckVersion(AdminClient adminClient) {
              Map<Properties, List<Integer>> versionsNodeMap = new HashMap<Properties, List<Integer>>();
  
              for(Integer nodeId: adminClient.getAdminClientCluster().getNodeIds()) {
                  Versioned<Properties> versionedProp = doMetaGetVersionsForNode_ExitOnError(adminClient,
                                                                                             nodeId);
                  Properties props = versionedProp.getValue();
                  if(versionsNodeMap.containsKey(props) == false) {
                      versionsNodeMap.put(props, new ArrayList<Integer>());
                  }
                  versionsNodeMap.get(props).add(nodeId);
              }
  
              if(versionsNodeMap.keySet().size() <= 0) {
                  System.err.println("No Versions found in the system store... something seriously wrong");
              } else if(versionsNodeMap.keySet().size() == 1) {
                  System.err.println("All the nodes have the same metadata versions.");
                  printProperties(versionsNodeMap.keySet().iterator().next());
              } else {
                  System.err.println("Mismatching versions detected !!! . All are supposed to be written by the same client "
                                     + ""
                                     + " and hence they should exactly match but something different, let us analyze deeper ");
                  Map<String, Map<String, List<Integer>>> propertyValueMap = new HashMap<String, Map<String, List<Integer>>>();
                  for(Entry<Properties, List<Integer>> entry: versionsNodeMap.entrySet()) {
                      System.out.println("**************************** Node(s): "
                                         + Arrays.toString(entry.getValue().toArray())
                                         + " ****************************");
                      Properties props = entry.getKey();
                      printProperties(props);
  
                      for(String propName: props.stringPropertyNames()) {
                          String propValue = props.getProperty(propName);
  
                          if(propertyValueMap.containsKey(propName) == false) {
                              propertyValueMap.put(propName, new HashMap<String, List<Integer>>());
                          }
                          Map<String, List<Integer>> valuetoNodeMap = propertyValueMap.get(propName);
                          if(valuetoNodeMap.containsKey(propValue) == false) {
                              valuetoNodeMap.put(propValue, new ArrayList<Integer>());
                          }
                          valuetoNodeMap.get(propValue).addAll(entry.getValue());
                      }
                  }
                  
                  System.out.println("########## Properties discrepancy report ########");
                  for(Entry<String, Map<String, List<Integer>>> entry: propertyValueMap.entrySet()) {
                      Map<String, List<Integer>> valueToNodeMap = entry.getValue();
                      String propName = entry.getKey();
                      List<Integer> allNodeIds = new ArrayList<Integer>();
                      allNodeIds.addAll(adminClient.getAdminClientCluster().getNodeIds());
                      
                      List<Integer> nodesWithValues = new ArrayList<Integer>();
                      if(valueToNodeMap.size() != 1) {
                          System.out.println("Properties with multiple values");
                          for(Entry<String, List<Integer>> valueToNodeEntry: valueToNodeMap
                                                                                .entrySet()) {
                              String propValue = valueToNodeEntry.getKey();
                              nodesWithValues.addAll(valueToNodeEntry.getValue());
                              printProperty(propName, propValue, valueToNodeEntry.getValue());
                          }
                      } else  {
                          Map.Entry<String, List<Integer>> valueToNodeEntry = valueToNodeMap.entrySet()
                                                                                            .iterator()
                                                                                            .next();
  
                          nodesWithValues.addAll(valueToNodeEntry.getValue());
                          if(nodesWithValues.size() < allNodeIds.size()) {
                              String propValue = valueToNodeEntry.getKey();
                              printProperty(propName, propValue, valueToNodeEntry.getValue());
                          }
                      }
  
                      allNodeIds.removeAll(nodesWithValues);
                      if(allNodeIds.size() > 0) {
                          System.out.println("The Property " + propName + " is present in the nodes "
                                             + Arrays.toString(nodesWithValues.toArray())
                                             + " but missing from the nodes "
                                             + Arrays.toString(allNodeIds.toArray()));
                      }
                  }
              }
          }