private void assertIoFiles(final File summaryFile, final File detailsFile, final File plotsFile) { IOUtil.assertFileIsReadable(INPUT); IOUtil.assertFileIsReadable(REFERENCE_SEQUENCE); IOUtil.assertFileIsWritable(summaryFile); IOUtil.assertFileIsWritable(detailsFile); IOUtil.assertFileIsWritable(plotsFile); }
/** * Delete any temporary files. After this method is called, iterator() may not be called. */ public void cleanup() { this.iterationStarted = true; this.cleanedUp = true; IOUtil.deleteFiles(this.files); }
private VariantContextJavascriptFilter(final File scriptFile, final VCFHeader header) throws IOException { super(scriptFile, header); this.scriptFile = scriptFile; /* create filter name using file basename */ String fname = IOUtil.basename(scriptFile); if (fname.isEmpty()) fname = "JSFILTER"; this.filterName = fname; }
static void assertWritable(final File output, final boolean outputByReadGroup) { if (outputByReadGroup) { if (output != null) { IOUtil.assertDirectoryIsWritable(output); } } else { IOUtil.assertFileIsWritable(output); } }
private static OutputStream maybeMd5Wrap(final File file, final boolean createMd5) { if (createMd5) { return IOUtil.openFileForMd5CalculatingWriting(file); } else { return IOUtil.openFileForWriting(file); } } }
/** * Write out a file of read names for debugging purposes. * * @param samOrBamFile The SAM or BAM file for which we are going to write out a file of its * containing read names */ private void writeReadsFile(final File samOrBamFile) throws IOException { final File readsFile = new File(OUTPUT.getParentFile(), IOUtil.basename(samOrBamFile) + ".reads"); IOUtil.assertFileIsWritable(readsFile); try (final SamReader reader = SamReaderFactory.makeDefault().referenceSequence(REFERENCE_SEQUENCE).open(samOrBamFile); final BufferedWriter bw = IOUtil.openFileForBufferedWriting(readsFile, false)) { for (final SAMRecord rec : reader) { bw.write(rec.toString() + "\n"); } } IOUtil.assertFileIsReadable(readsFile); }
@Override protected int doWork() { final List<File> inputs = IOUtil.unrollFiles(INPUT, BamFileIoUtils.BAM_FILE_EXTENSION, ".sam"); for (final File f : inputs) IOUtil.assertFileIsReadable(f); IOUtil.assertFileIsWritable(OUTPUT); if (determineBlockCopyingStatus(inputs)) { BamFileIoUtils.gatherWithBlockCopying(inputs, OUTPUT, CREATE_INDEX, CREATE_MD5_FILE); } else { gatherNormally(inputs, OUTPUT, CREATE_INDEX, CREATE_MD5_FILE, REFERENCE_SEQUENCE); } return 0; }
/** * Checks that each path is non-null, exists, is not a directory and is readable. If any * condition is false then a runtime exception is thrown. * * @param paths the list of paths to check for readability */ public static void assertPathsAreReadable(final List<Path> paths) { for (final Path path: paths) assertFileIsReadable(path); }
private void ensureArgs() { IOUtil.assertFileIsReadable(REFERENCE_SEQUENCE); for (File f : INPUT) { IOUtil.assertFileIsReadable(f); } if (WORKING_DIR == null) { WORKING_DIR = new File("."); } IOUtil.assertDirectoryIsWritable(WORKING_DIR); if (CONFIGURATION_FILE != null) { IOUtil.assertFileIsReadable(CONFIGURATION_FILE); } } public static void ensureIndexed(File fa) throws IOException {
private static InputStream[] filesToInputStreams(final File[] files) { final InputStream[] result = new InputStream[files.length]; for (int i = 0; i < files.length; i++) { result[i] = IOUtil.openFileForReading(files[i]); } return result; } }
@Override public Long call() throws Exception { IOUtil.copyStream(is, os); return 0L; }
/** * Opens a file for writing, overwriting the file if it already exists * * @param file the file to write to * @return the output stream to write to */ public static OutputStream openFileForWriting(final File file) { return openFileForWriting(file, false); }
public static File[] getTiledFiles(final File baseDirectory, final Pattern pattern) { return IOUtil.getFilesMatchingRegexp(baseDirectory, pattern); }
/** Returns all of the untrimmed lines in the provided file. */ public static List<String> slurpLines(final File file) throws FileNotFoundException { return slurpLines(new FileInputStream(file)); }
@Override protected void setup(final SAMFileHeader header, final File samFile) { IOUtil.assertFileIsWritable(OUTPUT); IOUtil.assertFileIsWritable(CHART_OUTPUT); // If we're working with a single library, assign that library's name // as a suffix to the plot title final List<SAMReadGroupRecord> readGroups = header.getReadGroups(); if (readGroups.size() == 1) { this.plotSubtitle = readGroups.get(0).getLibrary(); if (null == this.plotSubtitle) this.plotSubtitle = ""; } }
protected File getRunFile(final File baseDirectory, final Pattern pattern) { if (baseDirectory.exists()) { IOUtil.assertDirectoryIsReadable(baseDirectory); final File[] files = IOUtil.getFilesMatchingRegexp(baseDirectory, pattern); if (files.length == 1) { return files[0]; } } return null; }
public static void deleteRelativeFiles(final File baseFile, final List<String> relativeFilesToDelete) { for (final String relativeFile : relativeFilesToDelete) { final File actualFile = new File(baseFile, relativeFile); if (!actualFile.exists()) { throw new RuntimeException("Trying to delete a non-existent file" + actualFile.getAbsolutePath()); } if (actualFile.isDirectory()) { IOUtil.deleteDirectoryTree(actualFile); } else { IOUtil.deleteFiles(actualFile); } if (actualFile.exists()) { throw new RuntimeException("File still exists after calling delete: " + actualFile); } } }
/** * Checks that a directory is non-null, extent, writable and a directory * otherwise a runtime exception is thrown. * * @param dir the dir to check for writability */ public static void assertDirectoryIsWritable(final File dir) { final Path asPath = IOUtil.toPath(dir); assertDirectoryIsWritable(asPath); }
/** * Prepare to accumulate records * * @param codec For writing records to file and reading them back into RAM * @param maxRecordsInRam how many records to accumulate before spilling to disk * @param tmpDirs Where to write files of records that will not fit in RAM */ private DiskBackedQueue(final SortingCollection.Codec<E> codec, final int maxRecordsInRam, final List<Path> tmpDirs) { if (maxRecordsInRam < 0) { throw new IllegalArgumentException("maxRecordsInRamQueue must be >= 0"); } if (tmpDirs == null || tmpDirs.isEmpty()) { throw new IllegalArgumentException("At least one temp directory must be provided."); } for (final Path tmpDir : tmpDirs) IOUtil.assertDirectoryIsWritable(tmpDir); this.tmpDirs = tmpDirs; this.codec = codec; this.maxRecordsInRamQueue = (maxRecordsInRam == 0) ? 0 : maxRecordsInRam - 1; // the first of our ram records is stored as headRecord this.ramRecords = new ArrayDeque<E>(this.maxRecordsInRamQueue); }
/** * Write out a file of read names for debugging purposes. * * @param samOrBamFile The SAM or BAM file for which we are going to write out a file of its * containing read names */ private void writeReadsFile(final File samOrBamFile) throws IOException { final File readsFile = new File(OUTPUT.getParentFile(), IOUtil.basename(samOrBamFile) + ".reads"); IOUtil.assertFileIsWritable(readsFile); try (final SamReader reader = SamReaderFactory.makeDefault().referenceSequence(REFERENCE_SEQUENCE).open(samOrBamFile); final BufferedWriter bw = IOUtil.openFileForBufferedWriting(readsFile, false)) { for (final SAMRecord rec : reader) { bw.write(rec.toString() + "\n"); } } IOUtil.assertFileIsReadable(readsFile); }