private ByteSequencesReader sort() throws IOException { String prefix = getClass().getSimpleName(); Path directory = OfflineSorter.getDefaultTempDir(); tempInput = Files.createTempFile(directory, prefix, ".input"); tempSorted = Files.createTempFile(directory, prefix, ".sorted"); final OfflineSorter.ByteSequencesWriter writer = new OfflineSorter.ByteSequencesWriter(tempInput); boolean success = false; try { BytesRef spare; byte[] buffer = new byte[0]; ByteArrayDataOutput output = new ByteArrayDataOutput(buffer); while ((spare = source.next()) != null) { encode(writer, output, buffer, spare, source.payload(), source.contexts(), source.weight()); } writer.close(); new OfflineSorter(tieBreakByCostComparator).sort(tempInput, tempSorted); ByteSequencesReader reader = new OfflineSorter.ByteSequencesReader(tempSorted); success = true; return reader; } finally { if (success) { IOUtils.close(writer); } else { try { IOUtils.closeWhileHandlingException(writer); } finally { close(); } } } }
@Override public Engine createEngine() throws Exception { testFile = "jpa-test." + JpaH2DataStore.FILE_EXT; try { // File temp = Files.createTempFile("jpa-test", "." + JpaH2DataStore.FILE_EXT).toFile(); // temp.deleteOnExit(); testFile = Files.createTempFile("jpa-test", "." + JpaH2DataStore.FILE_EXT).toString(); } catch (final IOException ex) { Logger.getLogger(JpaH2EngineTest.class.getName()) .log(Level.SEVERE, ex.getLocalizedMessage(), ex); fail(); } EngineFactory.deleteDatabase(testFile); try { return EngineFactory.bootLocalEngine( testFile, EngineFactory.DEFAULT, PASSWORD, DataStoreType.H2_DATABASE); } catch (final Exception e) { fail(e.getMessage()); return null; } }
/** * Copies the content of a JAR resource to the destination specified before the container starts * up. Useful to add test configuration files before tests are run. * * @param resourceInputStream input stream to te he JAR resource to copy * @param destination destination relative to DDF_HOME * @return option object to include in a {@link #configureCustom()} method * @throws IOException thrown if a problem occurs while copying the resource */ protected Option installStartupFile(InputStream resourceInputStream, String destination) throws IOException { File tempFile = Files.createTempFile("StartupFile", ".temp").toFile(); tempFile.deleteOnExit(); FileUtils.copyInputStreamToFile(resourceInputStream, tempFile); return replaceConfigurationFile(destination, tempFile); }
@Test public void testLoadFromJar() throws Exception { File jar = Files.createTempFile("battlecode-test", ".jar").toFile(); jar.deleteOnExit(); ZipOutputStream z = new ZipOutputStream(new FileOutputStream(jar)); ZipEntry classEntry = new ZipEntry("instrumentertest/Nothing.class"); z.putNextEntry(classEntry); IOUtils.copy( getClass().getClassLoader().getResourceAsStream("instrumentertest/Nothing.class"), z); z.closeEntry(); z.close(); IndividualClassLoader jarLoader = new IndividualClassLoader( "instrumentertest", new IndividualClassLoader.Cache(jar.toURI().toURL())); Class<?> jarClass = jarLoader.loadClass("instrumentertest.Nothing"); URL jarClassLocation = jarClass.getResource("Nothing.class"); // EXTREMELY scientific assertTrue(jarClassLocation.toString().startsWith("jar:")); assertTrue(jarClassLocation.toString().contains(jar.toURI().toURL().toString())); }
private LameResult index(JarFile jar, JarEntry jarEntry) throws IOException, MojoExecutionException { // lib/spring.jar // suffix -> ".jar // prefix -> "spring" String name = jarEntry.getName(); int dotIndex = name.lastIndexOf('.'); String suffix = name.substring(dotIndex); int slashIndex = name.lastIndexOf('/'); String prefix; if (slashIndex == -1) { prefix = name.substring(0, dotIndex); } else { prefix = name.substring(slashIndex + 1, dotIndex); } Path tempPath = Files.createTempFile(prefix, suffix); File tempFile = tempPath.toFile(); try (InputStream input = jar.getInputStream(jarEntry)) { // Files.copy will do the buffering Files.copy(input, tempPath, REPLACE_EXISTING); } LameIndex lameIndex; try (JarFile tempJar = new JarFile(tempFile)) { lameIndex = index(tempJar); } boolean changed = lameIndex.changed; if (changed) { tempFile = writeIndexes(tempFile, name, lameIndex.subDeploymentIndices); return new LameResult(tempFile, true, lameIndex.index); } else { return new LameResult(null, false, null); } }
@BeforeClass public static void setUpClass() throws IOException { // Run before the test JVM starts to ensure the dynamic download // actually happens during the test run PropsUtil.setProps(new PropsImpl()); String jarName = PropsUtil.get(PropsKeys.SETUP_LIFERAY_POOL_PROVIDER_JAR_NAME, new Filter("hikaricp")); Path jarPath = Paths.get("lib/portal", jarName); if (Files.exists(jarPath)) { Path tempFilePath = Files.createTempFile(null, null); Files.move(jarPath, tempFilePath, StandardCopyOption.REPLACE_EXISTING); URI uri = tempFilePath.toUri(); URL url = uri.toURL(); System.setProperty(_HIKARICP_JAR_URL, url.toExternalForm()); } }
/** * Sends a GET request and returns the response. * * @param endpoint The endpoint to send the request to. * @param headers Any additional headers to send with this request. You can use {@link * org.apache.http.HttpHeaders} constants for header names. * @return A {@link Path} to the downloaded content, if any. * @throws IOException If an error occurs. * @see java.nio.file.Files#probeContentType(Path) */ public Response<Path> get(Endpoint endpoint, NameValuePair... headers) throws IOException { // Create the request HttpGet get = new HttpGet(endpoint.url()); get.setHeaders(combineHeaders(headers)); Path tempFile = null; // Send the request and process the response try (CloseableHttpResponse response = httpClient().execute(get)) { if (response.getStatusLine().getStatusCode() != HttpStatus.OK_200) { return null; } // If bad response return null // Request the content HttpEntity entity = response.getEntity(); // Download the content to a temporary file if (entity != null) { tempFile = Files.createTempFile("download", "file"); try (InputStream input = entity.getContent(); OutputStream output = Files.newOutputStream(tempFile)) { IOUtils.copy(input, output); } } return new Response<>(response.getStatusLine(), tempFile); } }
/** Create a jar file from the classes directory, creating it directly in the toolkit. */ private static String createJarFile(File toolkitLib, final File classesDir) throws IOException { final Path classesPath = classesDir.toPath(); Path jarPath = Files.createTempFile(toolkitLib.toPath(), "classes", ".jar"); try (final JarOutputStream jarOut = new JarOutputStream( new BufferedOutputStream(new FileOutputStream(jarPath.toFile()), 128 * 1024))) { Files.walkFileTree( classesDir.toPath(), new FileVisitor<Path>() { @Override public FileVisitResult preVisitDirectory(Path dir, BasicFileAttributes attrs) throws IOException { return FileVisitResult.CONTINUE; } @Override public FileVisitResult visitFile(Path file, BasicFileAttributes attrs) throws IOException { File classFile = file.toFile(); if (classFile.isFile()) { // Write the entry followed by the data. Path relativePath = classesPath.relativize(file); JarEntry je = new JarEntry(relativePath.toString()); je.setTime(classFile.lastModified()); jarOut.putNextEntry(je); final byte[] data = new byte[32 * 1024]; try (final BufferedInputStream classIn = new BufferedInputStream(new FileInputStream(classFile), data.length)) { for (; ; ) { int count = classIn.read(data); if (count == -1) break; jarOut.write(data, 0, count); } } jarOut.closeEntry(); } return FileVisitResult.CONTINUE; } @Override public FileVisitResult visitFileFailed(Path file, IOException exc) throws IOException { return FileVisitResult.CONTINUE; } @Override public FileVisitResult postVisitDirectory(Path dir, IOException exc) throws IOException { dir.toFile().delete(); return FileVisitResult.CONTINUE; } }); } return jarPath.getFileName().toString(); }
private Path dumpSearchResults(User user, Request request) throws ParseException, IOException, FileNotFoundException { user = userService.validate(user); Query query = searchService.getQuery(request); IndexSearcher searcher = getSearcher(request, user); Filter f = NumericRangeFilter.newLongRange( MailSchemaField.date.name(), request.startTime, request.endTime, true, true); TopDocs docs = searcher.search(query, f, request.scanSize); Path tempFile = Files.createTempFile(format("kw-%s-%s", user.id, request.keywordField), ".mailytics.temp"); PrintWriter writer = new PrintWriter(tempFile.toFile()); TIntHashSet dupSet = new TIntHashSet(); for (ScoreDoc sd : docs.scoreDocs) { Document doc = searcher.doc(sd.doc); String string = doc.get(request.keywordField.name()); int hash = string.hashCode(); if (!dupSet.contains(hash)) { writer.println(string); dupSet.add(hash); } } dupSet.clear(); writer.close(); return tempFile; }
private static String getCustomProperties() throws ReporterException { if (System.getProperty("reporter.config") == null) { return null; } File propFile = new File(System.getProperty("reporter.config")); if (!propFile.exists() || propFile.isDirectory()) { return null; } try { File file = Files.createTempFile("reporter", ".properties").toFile(); file.deleteOnExit(); FileWriter fw = new FileWriter(file); String fileText = new String(Files.readAllBytes(propFile.toPath())); // replace variables fileText = fileText.replace( "${file.separator}", Matcher.quoteReplacement(System.getProperty("file.separator"))); fileText = fileText.replace("${user.dir}", Matcher.quoteReplacement(System.getProperty("user.dir"))); fw.write(fileText); fw.close(); return file.getAbsolutePath(); } catch (IOException e) { throw new ReporterException( "Failed to read custom config file at: " + propFile.getAbsolutePath()); } }
/** * Uncompress a file to a temporary file. * * @param context Step context * @param file file to uncompress * @return the path to the uncompressed file * @throws IOException if an error occurs while creating the uncompressed file */ private File uncompressFile(final TaskContext context, final DataFile file) throws IOException { checkNotNull(file, "file argument cannot be null"); final DataFile realFile; final DataProtocol protocol = file.getProtocol(); // Get the underlying file if the file protocol is a storage protocol if (protocol instanceof StorageDataProtocol) { realFile = ((StorageDataProtocol) protocol).getUnderLyingData(file); } else { realFile = file; } final File outputFile = Files.createTempFile( context.getLocalTempDirectory().toPath(), MODULE_NAME + "-", realFile.getExtension()) .toFile(); context.getLogger().fine("Uncompress/copy " + realFile + " to " + outputFile); DataFiles.copy(realFile, new DataFile(outputFile)); return outputFile; }
public void testInvalidFormat(ImageResultVerifier... verifiers) throws IOException { Path tempFile = null; try { tempFile = Files.createTempFile("jtrim", ".test"); final ContextAwareTaskExecutor taskExecutor = TaskExecutors.contextAware(SyncTaskExecutor.getSimpleExecutor()); AsyncDataLink<ImageResult> link = create(tempFile, taskExecutor); ImageCollectorListener listener = new ImageCollectorListener(taskExecutor); AsyncDataController controller = link.getData(Cancellation.UNCANCELABLE_TOKEN, listener); assertNotNull(controller.getDataState()); controller.controlData(null); AsyncReport report = listener.getReport(); ImageResult lastResult = listener.getLastResult(); long imageCount = listener.getImageCount(); listener.verifyNoTrivialErrors(); assertEquals("Should not have received an image.", 0L, imageCount); ImageResultVerifier verifier = combineVerifiers(new FailedVerifier(Throwable.class), combineVerifiers(verifiers)); verifier.verifyImageResult(imageCount, lastResult, report); } finally { if (tempFile != null) { Files.deleteIfExists(tempFile); } } }
public static void reconstructTurtle(File partFolder, File reconstructed) throws IOException { Path tmpOut = Files.createTempFile(partFolder.toPath(), "reconstr", ".tmp"); FileOutputStream dstOut = new FileOutputStream(tmpOut.toFile()); FileChannel dstOutChannel = dstOut.getChannel(); try { if (!Files.isDirectory(partFolder.toPath())) throw new IOException("Not a directory: " + partFolder); File[] fileList = FileUtils.listFiles(partFolder, new PrefixFileFilter("part"), TrueFileFilter.TRUE) .toArray(new File[0]); Arrays.sort(fileList); RandomAccessFile inputFile; inputFile = new RandomAccessFile(fileList[0], "r"); inputFile.getChannel().transferTo(0, inputFile.length(), dstOutChannel); inputFile.close(); for (int i = 1; i < fileList.length; i++) { inputFile = new RandomAccessFile(fileList[i], "r"); long lastPrefix = findTurtlePrefixEnd(inputFile); inputFile .getChannel() .transferTo(lastPrefix, inputFile.length() - lastPrefix, dstOutChannel); inputFile.close(); } } finally { dstOut.close(); } Files.move( tmpOut, reconstructed.toPath(), StandardCopyOption.ATOMIC_MOVE, StandardCopyOption.REPLACE_EXISTING); FileUtils.deleteQuietly(tmpOut.toFile()); FileUtils.deleteQuietly(partFolder); }
public FileBucket() { try { path = Files.createTempFile(null, null); path.toFile().deleteOnExit(); } catch (IOException e) { } }
@Test public void testFileRollover() throws IOException { Path homeDir = Files.createTempDirectory("logger"); Path statusPath = Files.createTempFile("status", "dat"); ProtoLogger p = new ProtoLogger(homeDir.toString()); p.setMaxLogFile(500); for (int i = 0; i < 1000; i++) { p.write("topic-1", ByteString.copyFromUtf8(i + "")); } p.close(); ProtoSpout ps = new ProtoSpout( new ProtoSpout.TupleParser() { @Override public List<Object> parse(ByteString buffer) { return Collections.<Object>singletonList(buffer.toStringUtf8()); } @Override public Fields getOutputFields() { throw new UnsupportedOperationException("Default operation"); } }, statusPath.toFile(), new File(homeDir.toFile(), "topic-1"), Pattern.compile("[0-9a-f]*")); final List<List<Object>> tuples = Lists.newArrayList(); SpoutOutputCollector collector = new SpoutOutputCollector(null) { @Override public List<Integer> emit(List<Object> tuple) { tuples.add(tuple); return null; } @Override public List<Integer> emit(List<Object> tuple, Object messageId) { return emit(tuple); } }; ps.open(null, null, collector); for (int i = 0; i < 1000; i++) { ps.nextTuple(); } assertEquals(1000, tuples.size()); Iterator<List<Object>> ix = tuples.iterator(); for (int i = 0; i < 1000; i++) { List<Object> x = ix.next(); assertEquals(1, x.size()); assertEquals(i + "", x.get(0)); } }
public void injectIcon(int id, final InputStream iconStream) throws IOException { Path f = Files.createTempFile("launcher", "ico"); try { Files.copy(iconStream, f, StandardCopyOption.REPLACE_EXISTING); } finally { iconStream.close(); } new IconResourceInjector().injectIcon(f.toFile(), myRoot, "IRD" + id); }
@Test public void testFile() { List<String> stringData = new ArrayList<>(); for (int i = 0; i < 100; i++) { stringData.add(UUID.randomUUID().toString()); } List<Integer> integerData = new ArrayList<>(); for (String uuid : stringData) { integerData.add(uuid.hashCode()); } File tempFile = null; try { tempFile = Files.createTempFile("test", "").toFile(); tempFile.deleteOnExit(); } catch (IOException e) { fail(e.toString()); } try (FileOutputStream fos = new FileOutputStream(tempFile)) { BinaryStreamDriver bsd = new BinaryStreamDriver(); XStream xstream = new XStream(bsd); try (ObjectOutputStream out = xstream.createObjectOutputStream(fos)) { out.writeObject(stringData); out.writeObject(integerData); } } catch (IOException e) { fail(e.toString()); } assertTrue(FileMagic.isBinaryXStreamFile(tempFile)); assertFalse(FileMagic.isOfxV2(tempFile)); try (FileInputStream fis = new FileInputStream(tempFile)) { BinaryStreamDriver bsd = new BinaryStreamDriver(); XStream xstream = new XStream(bsd); try (ObjectInputStream in = xstream.createObjectInputStream(fis)) { List<?> strings = (List<?>) in.readObject(); List<?> integers = (List<?>) in.readObject(); assertArrayEquals(strings.toArray(), stringData.toArray()); assertArrayEquals(integers.toArray(), integerData.toArray()); } catch (ClassNotFoundException e) { fail(e.toString()); } } catch (IOException e) { fail(e.toString()); } }
@Override public IExtendedScannerInfo getDefaultScannerInfo( IBuildConfiguration buildConfig, IExtendedScannerInfo baseScannerInfo, ILanguage language, URI buildDirectoryURI) { try { String[] commands = getCompileCommands(language); if (commands == null || commands.length == 0) { // no default commands return null; } Path buildDirectory = Paths.get(buildDirectoryURI); // Pick the first one Path command = Paths.get(commands[0]); List<String> commandLine = new ArrayList<>(); if (command.isAbsolute()) { commandLine.add(command.toString()); } else { commandLine.add(getCommandPath(command).toString()); } if (baseScannerInfo != null && baseScannerInfo.getIncludePaths() != null) { for (String includePath : baseScannerInfo.getIncludePaths()) { commandLine.add("-I" + includePath); // $NON-NLS-1$ } } addDiscoveryOptions(commandLine); // output to stdout commandLine.add("-o"); // $NON-NLS-1$ commandLine.add("-"); // $NON-NLS-1$ // Source is an empty tmp file String extension; if (GPPLanguage.ID.equals(language.getId())) { extension = ".cpp"; } else if (GCCLanguage.ID.equals(language.getId())) { extension = ".c"; } else { // In theory we shouldn't get here return null; } Path tmpFile = Files.createTempFile(buildDirectory, ".sc", extension); // $NON-NLS-1$ commandLine.add(tmpFile.toString()); return getScannerInfo(buildConfig, commandLine, buildDirectory, tmpFile); } catch (IOException e) { Activator.log(e); return null; } }
private boolean canCreate(String pathPart) { try { Path tempFile = Files.createTempFile(pathPart, "canCreate"); Files.deleteIfExists(tempFile); return true; } catch (Exception e) { logger.log(Level.SEVERE, "WARNING: Cannot create file: " + pathPart); return false; } }
@Slow @Test public void testProxyWithBigResponseContentWithSlowReader() throws Exception { prepareProxy(); // Create a 6 MiB file final int length = 6 * 1024; Path targetTestsDir = MavenTestingUtils.getTargetTestingDir().toPath(); Files.createDirectories(targetTestsDir); final Path temp = Files.createTempFile(targetTestsDir, "test_", null); byte[] kb = new byte[1024]; new Random().nextBytes(kb); try (OutputStream output = Files.newOutputStream(temp, StandardOpenOption.CREATE)) { for (int i = 0; i < length; ++i) output.write(kb); } prepareServer( new HttpServlet() { @Override protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException { try (InputStream input = Files.newInputStream(temp)) { IO.copy(input, response.getOutputStream()); } } }); Request request = client.newRequest("localhost", serverConnector.getLocalPort()).path("/proxy/test"); final CountDownLatch latch = new CountDownLatch(1); request.send( new BufferingResponseListener(2 * length * 1024) { @Override public void onContent(Response response, ByteBuffer content) { try { // Slow down the reader TimeUnit.MILLISECONDS.sleep(5); super.onContent(response, content); } catch (InterruptedException x) { response.abort(x); } } @Override public void onComplete(Result result) { Assert.assertFalse(result.isFailed()); Assert.assertEquals(200, result.getResponse().getStatus()); Assert.assertEquals(length * 1024, getContent().length); latch.countDown(); } }); Assert.assertTrue(latch.await(30, TimeUnit.SECONDS)); }
@Override public Path getTempFile() { checkFileStructure(); Path path = Paths.get(pathFile.toString(), FILE_SYSTEM, TEMP); try { path = Files.createTempFile(path, null, ".txt"); return path; } catch (IOException e) { FileSystemLogging.logger.log(Level.FINE, "IOException while creating temp file", e); return null; } }
public static SyncFile updateFileSyncFile(Path filePath, long syncAccountId, SyncFile syncFile) throws Exception { // Local sync file if (FileUtil.getFileKey(filePath) != syncFile.getSyncFileId()) { FileUtil.writeFileKey(filePath, String.valueOf(syncFile.getSyncFileId())); } Path deltaFilePath = null; String name = _getName(filePath, syncFile); String sourceChecksum = syncFile.getChecksum(); String sourceFileName = syncFile.getName(); long sourceVersionId = syncFile.getVersionId(); String targetChecksum = FileUtil.getChecksum(filePath); if (!FileUtil.checksumsEqual(sourceChecksum, targetChecksum) && !IODeltaUtil.isIgnoredFilePatchingExtension(syncFile)) { deltaFilePath = Files.createTempFile(String.valueOf(filePath.getFileName()), ".tmp"); deltaFilePath = IODeltaUtil.delta(filePath, IODeltaUtil.getChecksumsFilePath(syncFile), deltaFilePath); IODeltaUtil.checksums(syncFile); } syncFile.setChecksum(targetChecksum); syncFile.setFilePathName(filePath.toString()); syncFile.setName(name); update(syncFile); // Remote sync file if ((syncFile.getState() != SyncFile.STATE_ERROR) && (syncFile.getState() != SyncFile.STATE_UNSYNCED)) { FileEventUtil.updateFile( filePath, syncAccountId, syncFile, deltaFilePath, name, sourceChecksum, sourceFileName, sourceVersionId, targetChecksum); } return syncFile; }
public Optional<File> intoDirectory(Path path) { if (WebDriverFactory.isAlive(driver)) { try { Path pageSourceFile = Files.createTempFile(path, "pagesource", ".html.txt"); Files.write(pageSourceFile, pageSource()); return Optional.of(pageSourceFile.toFile()); } catch (IOException couldNotCreatePageSourcce) { LOGGER.warn("Could not save the page source HTML file", couldNotCreatePageSourcce); } } return Optional.absent(); }
// Test borrowed from BytesAndLines public void testLines() throws IOException { final Charset US_ASCII = Charset.forName("US-ASCII"); Path tmpfile = Files.createTempFile("blah", "txt"); try { // zero lines assertTrue(Files.size(tmpfile) == 0, "File should be empty"); try (Stream<String> s = Files.lines(tmpfile)) { checkLines(s, Collections.emptyList()); } try (Stream<String> s = Files.lines(tmpfile, US_ASCII)) { checkLines(s, Collections.emptyList()); } // one line List<String> oneLine = Arrays.asList("hi"); Files.write(tmpfile, oneLine, US_ASCII); try (Stream<String> s = Files.lines(tmpfile)) { checkLines(s, oneLine); } try (Stream<String> s = Files.lines(tmpfile, US_ASCII)) { checkLines(s, oneLine); } // two lines using platform's line separator List<String> twoLines = Arrays.asList("hi", "there"); Files.write(tmpfile, twoLines, US_ASCII); try (Stream<String> s = Files.lines(tmpfile)) { checkLines(s, twoLines); } try (Stream<String> s = Files.lines(tmpfile, US_ASCII)) { checkLines(s, twoLines); } // MalformedInputException byte[] bad = {(byte) 0xff, (byte) 0xff}; Files.write(tmpfile, bad); try (Stream<String> s = Files.lines(tmpfile)) { checkMalformedInputException(s); } try (Stream<String> s = Files.lines(tmpfile, US_ASCII)) { checkMalformedInputException(s); } // NullPointerException checkNullPointerException(() -> Files.lines(null)); checkNullPointerException(() -> Files.lines(null, US_ASCII)); checkNullPointerException(() -> Files.lines(tmpfile, null)); } finally { Files.delete(tmpfile); } }
@Test public void executableExample() throws Exception { // Test final Path tempFile = Files.createTempFile("sc", ".out").toAbsolutePath(); ExecutableExample.main(new String[] {tempFile.toString()}); final List<String> failures = compareOutput("ExecutableExample.html", tempFile, TextOutputFormat.html.name()); if (failures.size() > 0) { fail(failures.toString()); } }
@Test public void test() throws IOException { final Path tempFile = Files.createTempFile("log4j2", ".xml"); try { final Log4j1ConfigurationConverter.CommandLineArguments cla = new Log4j1ConfigurationConverter.CommandLineArguments(); cla.setPathIn(pathIn); cla.setPathOut(tempFile); Log4j1ConfigurationConverter.run(cla); } finally { Files.deleteIfExists(tempFile); } }
private void testWrite(AssetFile asset) throws IOException { Path tmpFile = Files.createTempFile("disunity", null); try { asset.save(tmpFile); if (!FileUtils.contentEquals(asset.getSourceFile().toFile(), tmpFile.toFile())) { throw new IOException("Files are not equal"); } } finally { Files.deleteIfExists(tmpFile); } }
/* * Read POST uploads and write them to a temp file, returning the Path to that file. */ private static Path readUpload(ByteBuf content) throws IOException { byte[] bytes = new byte[content.readableBytes()]; content.readBytes(bytes); content.release(); // write to a temp file Path imgIn = Files.createTempFile("upload", ".jpg"); Files.write(imgIn, bytes); imgIn.toFile().deleteOnExit(); return imgIn; }
/** * Creates a zip file of the metadata and recorded artifacts and stores it in the artifact cache. */ public void performUploadToArtifactCache( ImmutableSet<RuleKey> ruleKeys, ArtifactCache artifactCache, BuckEventBus eventBus) throws InterruptedException { // Skip all of this if caching is disabled. Although artifactCache.store() will be a noop, // building up the zip is wasted I/O. if (!artifactCache.isStoreSupported()) { return; } ArtifactCompressionEvent.Started started = ArtifactCompressionEvent.started(ArtifactCompressionEvent.Operation.COMPRESS, ruleKeys); eventBus.post(started); final Path zip; ImmutableSet<Path> pathsToIncludeInZip = ImmutableSet.of(); ImmutableMap<String, String> buildMetadata; try { pathsToIncludeInZip = getRecordedDirsAndFiles(); zip = Files.createTempFile( "buck_artifact_" + MoreFiles.sanitize(buildTarget.getShortName()), ".zip"); buildMetadata = getBuildMetadata(); projectFilesystem.createZip(pathsToIncludeInZip, zip, ImmutableMap.<Path, String>of()); } catch (IOException e) { eventBus.post( ConsoleEvent.info( "Failed to create zip for %s containing:\n%s", buildTarget, Joiner.on('\n').join(ImmutableSortedSet.copyOf(pathsToIncludeInZip)))); e.printStackTrace(); return; } finally { eventBus.post(ArtifactCompressionEvent.finished(started)); } // Store the artifact, including any additional metadata. ListenableFuture<Void> storeFuture = artifactCache.store(ruleKeys, buildMetadata, BorrowablePath.notBorrowablePath(zip)); storeFuture.addListener( new Runnable() { @Override public void run() { try { Files.deleteIfExists(zip); } catch (IOException e) { throw new RuntimeException(e); } } }, directExecutor()); }
private static void testGetImage(String format, GetImageTest test) throws Throwable { Path tempFile = null; try { tempFile = Files.createTempFile("jtrim", ".test"); BufferedImage testImage = createTestImageWithoutAlpha(TEST_IMG_WIDTH, TEST_IMG_HEIGHT); ImageIO.write(testImage, format, tempFile.toFile()); test.testGetImage(tempFile); } finally { if (tempFile != null) { Files.deleteIfExists(tempFile); } } }