docs: public static List<String> getReadOnlyReplicationInfo(AdminClient adminClient,
                                                            Integer nodeId,
                                                            Boolean local) {
          List<String> infoList = Lists.newArrayList();
          Cluster cluster = adminClient.getAdminClientCluster();
          List<StoreDefinition> storeDefs = adminClient.rebalanceOps.getCurrentStoreDefinitionsExcept(cluster, nodeId);
  
          for(StoreDefinition storeDef: storeDefs) {
              String storeName = storeDef.getName();
              // Skip a store without replication, or has wrong ro storage format.
              String storageFormat = null;
              if(storeDef.getReplicationFactor() <= 1) {
                  logger.error("Store " + storeName +
                          " cannot be restored, as it has replication factor = "
                          + storeDef.getReplicationFactor());
                  continue;
              }
              if(!storeDef.getType().equals(ReadOnlyStorageConfiguration.TYPE_NAME)) {
                  logger.error("Store " + storeName +
                          " cannot be restored, as it has type = " +
                          storeDef.getType() +
                          " instead of " +
                          ReadOnlyStorageConfiguration.TYPE_NAME);
                  continue;
              }
  
              logger.info("Processing store " + storeName);
  
              RoutingStrategy strategy = new RoutingStrategyFactory().updateRoutingStrategy(storeDef,
                      cluster);
  
              // Go over the entire partitions and find if the destination node
              // belong in the replication partition list
              for(int masterPartitionId = 0; masterPartitionId < cluster.getNumberOfPartitions(); ++masterPartitionId) {
                  List<Integer> naryPartitionIds = strategy.getReplicatingPartitionList(masterPartitionId);
                  int nary = 0;
                  Boolean hasPartition = false;
  
                  for(int naryPartitionId: naryPartitionIds) {
                      Node naryNode = cluster.getNodeForPartitionId(naryPartitionId);
                      if(naryNode.getId() == nodeId) {
                          // Test if destination node has the partition of
                          // masterPartitionId, and record what kind of replica it
                          // is and break out of the loop
                          hasPartition = true;
                          naryPartitionIds.remove(nary);
                          break;
                      }
                      nary++;
                  }
  
                  if(!hasPartition) {
                      logger.trace("Node " + nodeId + " doesn't have partition " + masterPartitionId);
                      continue;
                  }
  
                  // Now find out which node hosts one of these replicas
                  Node sourceNode = cluster.getNodeForPartitionId(naryPartitionIds.get(0));
                  Integer sourceNodeId = sourceNode.getId();
                  Long version = adminClient.readonlyOps.getROCurrentVersion(sourceNodeId,
                          Arrays.asList(storeName))
                          .get(storeName);
  
                  // Now get all the file names from this node.
                  List<String> fileNames = null;
                  if(local) {
                      List<Integer> srcPartitionIds = Lists.newArrayList();
                      srcPartitionIds.addAll(sourceNode.getPartitionIds());
                      fileNames = getROStorageFileListLocally(srcPartitionIds, strategy);
                  } else {
                      fileNames = adminClient.readonlyOps.getROStorageFileList(sourceNode.getId(),
                              storeName);
                  }
  
                  List<String> sourceFileNames = parseAndCompare(fileNames, masterPartitionId);
  
                  // Compare if there are files that relate to the
                  // masterPartitionId
                  if(sourceFileNames.size() > 0) {
  
                      for(String sourceFileName: sourceFileNames) {
  
                          String[] partitionIdReplicaChunk = sourceFileName.split(SPLIT_LITERAL);
                          // At the destination node the replicaId will be
                          // different, so only change it to nary
                          String partitionId = partitionIdReplicaChunk[0];
                          String replicaId = String.valueOf(nary);
                          String chunkId = partitionIdReplicaChunk[2];
                          // Now concat the parts together to create the file name
                          // on the destination node
                          String destFileName = partitionId.concat(SPLIT_LITERAL)
                                  .concat(replicaId)
                                  .concat(SPLIT_LITERAL)
                                  .concat(chunkId);
                          String sourceRelPath = storeName + "/version-" + version + "/"
                                  + sourceFileName;
                          String destRelPath = storeName + "/version-" + version + "/" + destFileName;
  
                          infoList.add(sourceNode.getHost() + "," + sourceNode.getId() + ","
                                  + sourceRelPath + "," + destRelPath);
                      }
                  } else {
                      logger.warn("Cannot find file for partition " + masterPartitionId
                              + " on source node " + sourceNode.getId());
                  }
              }
          }
          return infoList;
      }