Get the logFileDetails of all the list of attempts passed.

@param lInfo
@return a map of task to the log-file detail
@throws IOException
974857
private Map<Task, Map<LogName, LogFileDetail>> getAllLogsFileDetails(
      final List<Task> allAttempts) throws IOException {
    Map<Task, Map<LogName, LogFileDetail>> taskLogFileDetails =
        new HashMap<Task, Map<LogName, LogFileDetail>>();
    for (Task task : allAttempts) {
      Map<LogName, LogFileDetail> allLogsFileDetails;
      allLogsFileDetails =
          TaskLog.getAllLogsFileDetails(task.getTaskID(),
              task.isTaskCleanupTask());
      taskLogFileDetails.put(task, allLogsFileDetails);
    }
    return taskLogFileDetails;
  }
783256
Map<String, LocalResource> getResources(
      final ResourceLaunchEvent resourceLaunchEvent)
      throws IOException {

    final Map<String, LocalResource> result = new HashMap<>();
    result.putAll(getGlobalResources());

    final File localStagingFolder = this.tempFileCreator.createTempDirectory(this.fileNames.getEvaluatorFolderPrefix());

    // Write the configuration
    final File configurationFile = new File(localStagingFolder, this.fileNames.getEvaluatorConfigurationName());
    this.configurationSerializer.toFile(makeEvaluatorConfiguration(resourceLaunchEvent), configurationFile);

    // Copy files to the staging folder
    JobJarMaker.copy(resourceLaunchEvent.getFileSet(), localStagingFolder);

    // Make a JAR file out of it
    final File localFile = tempFileCreator.createTempFile(
        this.fileNames.getEvaluatorFolderPrefix(), this.fileNames.getJarFileSuffix());
    new JARFileMaker(localFile).addChildren(localStagingFolder).close();

    // Upload the JAR to the job folder
    final Path pathToEvaluatorJar = this.uploader.uploadToJobFolder(localFile);
    result.put(this.fileNames.getLocalFolderPath(), this.uploader.makeLocalResourceForJarFile(pathToEvaluatorJar));

    if (this.deleteTempFiles) {
      LOG.log(Level.FINE, "Marking [{0}] for deletion at the exit of this JVM and deleting [{1}]",
          new Object[]{localFile.getAbsolutePath(), localStagingFolder.getAbsolutePath()});
      localFile.deleteOnExit();
      if (!localStagingFolder.delete()) {
        LOG.log(Level.WARNING, "Failed to delete [{0}]", localStagingFolder.getAbsolutePath());
      }
    } else {
      LOG.log(Level.FINE, "The evaluator staging folder will be kept at [{0}], the JAR at [{1}]",
          new Object[]{localFile.getAbsolutePath(), localStagingFolder.getAbsolutePath()});
    }
    return result;
  }
375050
@Override
    public Iterable<ServerInstanceLogRecordList> getLogLists() {
        return getLogLists((Date) null, (Date) null, (LogRecordHeaderFilter) null);
    }
1195029
public String[] list() throws IOException {
    FileStatus[] fileStatus =
        fs.listStatus(directory, LuceneIndexFileNameFilter.getFilter());
    String[] result = new String[fileStatus.length];
    for (int i = 0; i < fileStatus.length; i++) {
      result[i] = fileStatus[i].getPath().getName();
    }
    return result;
  }
838251
public String[] getHardLinkedFiles(String src) throws IOException {
    byte[][] components = INode.getPathComponents(src);
    List<byte [][]> results = null;
    readLock();
    try {
      INodeFile inode = getFileINode(components);
      if (!exists(inode)) {
        throw new IOException(src + " does not exist");
      }
      if (inode instanceof INodeHardLinkFile) {
        HardLinkFileInfo info = ((INodeHardLinkFile) inode)
          .getHardLinkFileInfo();
        // Only get the list of names as byte arrays under the lock.
        results = new ArrayList<byte[][]>(info.getReferenceCnt());
        for (int i = 0; i < info.getReferenceCnt(); i++) {
          try {
            results.add(getINodeByteArray(info.getHardLinkedFile(i)));
          } catch (IOException ioe) {
            NameNode.LOG.info("Hardlink may have been deleted", ioe);
          }
        }
      } else {
        return new String[] {};
      }
    } finally {
      readUnlock();
    }

    // Convert byte arrays to strings outside the lock since this is expensive.
    String[] files = new String[results.size()-1];
    int size = 0;
    for (int i = 0; i < results.size(); i++) {
      String file = getFullPathName(results.get(i));
      if (!file.equals(src)) {
        if (size >= files.length) {
          throw new IOException(src + " is not part of the list of hardlinked "
              + "files! This is a serious bug!");
        }
        files[size++] = file;
      }
    }
    return files;
  }
953170
private String getLogFiles(Logger logger) {

        String test = "";
        int count = 0;
        // select the Appender from logger
        for (Appender appender : logger.getAppenders().values()) {
            // only use file appenders
            if (CmsLogFileApp.isFileAppender(appender)) {
                String fileName = CmsLogFileApp.getFileName(appender);
                String temp = "";
                temp = fileName.substring(fileName.lastIndexOf(File.separatorChar) + 1);
                test = test + temp;
                count++;
                break;
            }
        }

        //iterate all parent loggers until a logger with appender was found
        while (!logger.equals(LogManager.getRootLogger())) {

            logger = logger.getParent();
            // if no Appender found from logger, select the Appender from parent logger
            if (count == 0) {
                for (Appender appender : logger.getAppenders().values()) {
                    // only use file appenders
                    if (CmsLogFileApp.isFileAppender(appender)) {
                        String fileName = CmsLogFileApp.getFileName(appender);
                        String temp = "";
                        temp = fileName.substring(fileName.lastIndexOf(File.separatorChar) + 1);
                        test = test + temp;
                        count++;
                        break;
                    }
                }
            }
        }

        return test;
    }
1086047
List<RemoteEditLog> getManifest() throws IOException {
    RemoteEditLogManifest rm = remoteJournalManager.getEditLogManifest(-1);
    if (rm == null || rm.getLogs().size() == 0) {
      throw new IOException("Cannot obtain the list of log segments");
    }
    return rm.getLogs();
  }
205478
public Path getOutputFile(TaskAttemptID mapTaskId)
    throws IOException {
    return lDirAlloc.getLocalPathToRead(TaskTracker.getIntermediateOutputDir(
                       jobId.toString(), mapTaskId.toString())
                       + "/file.out", conf);
  }
790673
private void checkSrcLogFiles() throws IOException {
    List<FileStatus> srcLogFiles = new ArrayList<>();

    for (Path logDirPath: this.srcLogDirs) {
      srcLogFiles.addAll(FileListUtils.listFilesRecursively(this.srcFs, logDirPath, new PathFilter() {
        @Override
        public boolean accept(Path path) {
          return LogCopier.this.logFileExtensions.contains(Files.getFileExtension(path.getName()));
        }
      }));
    }

    if (srcLogFiles.isEmpty()) {
      LOGGER.warn("No log file found under directories " + this.srcLogDirs);
      return;
    }

    Set<Path> newLogFiles = Sets.newHashSet();
    for (FileStatus srcLogFile : srcLogFiles) {
      newLogFiles.add(srcLogFile.getPath());
    }

    HashSet<Path> deletedLogFiles = Sets.newHashSet(getSourceFiles());
    // Compute the set of deleted log files since the last check
    deletedLogFiles.removeAll(newLogFiles);
    // Compute the set of new log files since the last check
    newLogFiles.removeAll(getSourceFiles());

    // Schedule a copy task for each new log file
    for (final Path srcLogFile : newLogFiles) {
      String destLogFileName = this.logFileNamePrefix.isPresent()
          ? this.logFileNamePrefix.get() + "." + srcLogFile.getName() : srcLogFile.getName();
      final Path destLogFile = new Path(this.destLogDir, destLogFileName);

      this.scheduler.schedule(new LogCopyTask(srcLogFile, destLogFile), this.copyInterval, this.timeUnit);
    }

    // Cancel the copy task for each deleted log file
    for (Path deletedLogFile : deletedLogFiles) {
      Optional<LogCopyTask> logCopyTask = this.scheduler.getScheduledTask(deletedLogFile);
      if (logCopyTask.isPresent()) {
        this.scheduler.cancel(logCopyTask.get());
      }
    }
  }
842873
protected List<File> getClassPath() throws IOException {
		final Set<String> classPath = new LinkedHashSet<>();
		classPath.add(this.session.getCurrentProject().getBuild().getSourceDirectory());
		try {
			classPath.addAll(this.session.getCurrentProject().getCompileClasspathElements());
		} catch (DependencyResolutionRequiredException e) {
			throw new IOException(e.getLocalizedMessage(), e);
		}
		for (final Artifact dep : this.session.getCurrentProject().getArtifacts()) {
			classPath.add(dep.getFile().getAbsolutePath());
		}
		classPath.remove(this.session.getCurrentProject().getBuild().getOutputDirectory());
		final List<File> files = new ArrayList<>();
		for (final String filename : classPath) {
			final File file = new File(filename);
			if (file.exists()) {
				files.add(file);
			}
		}
		return files;
	}
417374
public List<String> readList() throws IOException
   {
      InputStream in = PrivilegedFileHelper.fileInputStream(logFile);
      try
      {
         List<String> list = new ArrayList<String>();
         BufferedReader reader = new BufferedReader(new InputStreamReader(in));
         String line;
         while ((line = reader.readLine()) != null)
         {
            if (!line.matches("\\x00++"))
            {
               list.add(line);
            }
         }
         return list;

      }
      finally
      {
         if (in != null)
         {
            try
            {
               in.close();
            }
            catch (IOException e)
            {
               LOG.warn("Exception while closing error log: " + e.toString());
            }
         }
      }
   }
303898
protected List<String> getPluginsPath() throws IOException {
        List<String> result = new ArrayList<>();
        Path pluginsDirectory = PROPERTIES.getAllureHome().resolve("plugins").toAbsolutePath();
        if (Files.notExists(pluginsDirectory)) {
            return Collections.emptyList();
        }

        try (DirectoryStream<Path> plugins = Files.newDirectoryStream(pluginsDirectory, JAR_FILES)) {
            for (Path plugin : plugins) {
                result.add(plugin.toUri().toURL().toString());
            }
        }
        return result;
    }
944463
public List<LogMessage> getLogs() {
        final ArrayList<LogMessage> messages = new ArrayList<LogMessage>();
        for (final String logName : logs.keySet()) {
            messages.addAll(logs.get(logName).getLogMessages());
        }
        Collections.sort(messages, new LogMessageComparator());
        return messages;
    }
352966
public List<MapRow> read() throws IOException
   {
      List<MapRow> result = new ArrayList<MapRow>();
      int fileCount = m_stream.readInt();
      if (fileCount != 0)
      {
         for (int index = 0; index < fileCount; index++)
         {
            // We use a LinkedHashMap to preserve insertion order in iteration
            // Useful when debugging the file format.
            Map<String, Object> map = new LinkedHashMap<String, Object>();
            readBlock(map);
            result.add(new MapRow(map));
         }
      }
      return result;
   }
14161
public <T> File writeLines(Collection<T> list) throws IORuntimeException {
		return writeLines(list, false);
	}
957206
public static List<String> readLines(File file) throws IOException {
        return IOGroovyMethods.readLines(newReader(file));
    }
1120782
public java.util.List<FlowLog> getFlowLogs() {
        if (flowLogs == null) {
            flowLogs = new com.amazonaws.internal.SdkInternalList<FlowLog>();
        }
        return flowLogs;
    }