public static void main(String[] args) throws IOException { List<SystemProperty> properties = SystemPropertiesParser.parse(); System.out.println(NORMAL_GSON.toJson(properties)); Files.write(Paths.get("system_properties_min.json"), NORMAL_GSON.toJson(properties).getBytes()); Files.write(Paths.get("system_properties.json"), PRETTY_GSON.toJson(properties).getBytes()); createReadMe(properties); }
/** * By rotating hoge.E and hoge.N, output hoge.R and hoge.T The rotation is done by SAC. * * @param sacEPath SAC file which component is E. must exist. * @param sacNPath SAC file which component is N. must exist. * @param outputRPath for output SAC with respect to R * @param outputTPath for output SAC with respect to T * @return if the output is successful * @throws IOException if an I/O error occurs. If sacEPath or sacNPath does not exist, if output * Paths already exist. */ public static boolean rotate(Path sacEPath, Path sacNPath, Path outputRPath, Path outputTPath) throws IOException { if (Files.exists(outputRPath)) throw new FileAlreadyExistsException(outputRPath.toString()); if (Files.exists(outputTPath)) throw new FileAlreadyExistsException(outputTPath.toString()); // read headers of the input files Map<SACHeaderEnum, String> mapE = readHeader(sacEPath); Map<SACHeaderEnum, String> mapN = readHeader(sacNPath); int npts = Integer.parseInt(mapE.get(SACHeaderEnum.NPTS)); if (npts != Integer.parseInt(mapN.get(SACHeaderEnum.NPTS))) return false; double cmpazE = Double.parseDouble(mapE.get(SACHeaderEnum.CMPAZ)); double cmpazN = Double.parseDouble(mapN.get(SACHeaderEnum.CMPAZ)); double dCmpaz = Math.abs(cmpazE - cmpazN); if (dCmpaz != 90) return false; // sacを開く try (Sac sacProcess = Sac.createProcess()) { Path rPath = outputRPath.getFileName(); Path tPath = outputTPath.getFileName(); sacProcess.inputCMD("cd " + sacNPath.toAbsolutePath().getParent()); sacProcess.inputCMD("r " + sacNPath.getFileName() + " " + sacEPath.getFileName()); sacProcess.inputCMD("rotate r"); sacProcess.inputCMD("w " + rPath + " " + tPath); sacProcess.inputCMD("r " + rPath); sacProcess.inputCMD("chnhdr kcmpnm \"radial\""); sacProcess.inputCMD("write over"); sacProcess.inputCMD("r " + tPath); sacProcess.inputCMD("chnhdr kcmpnm \"trnsvers\""); sacProcess.inputCMD("write over"); } return true; }
/** * Test method for {@link SubtitleProvider#loadSubtitles(Path)}. Check that multiple subtitles are * loaded. * * @throws IOException if there was an I/O error. */ @Test public void testLoadSubtitles() throws IOException { final SubtitleFormat subtitleFormat = mock(SubtitleFormat.class); final SubtitleReader subtitleReader = mock(SubtitleReader.class); final SubtitleFile subtitleFile = mock(SubtitleFile.class); final SubtitleFile secondSubtitle = mock(SubtitleFile.class); final Path folder = subtitleFolder.newFolder().toPath(); final Path file = folder.resolve("single.srt"); final Path second = folder.resolve("other.srt"); Files.createFile(file); Files.createFile(second); Files.createFile(folder.resolve("test.sub")); when(subtitleFormatManager.getFormatByPath(file)) .thenReturn(new HashSet<>(Arrays.asList(subtitleFormat))); when(subtitleFormatManager.getFormatByPath(second)) .thenReturn(new HashSet<>(Arrays.asList(subtitleFormat))); when(subtitleFormat.getReader()).thenReturn(subtitleReader); when(subtitleReader.readFile(file)).thenReturn(subtitleFile); when(subtitleReader.readFile(second)).thenReturn(secondSubtitle); final Map<SubtitleFile, SubtitleFormat> subtitles = subtitleProvider.loadSubtitles(folder); assertEquals(2, subtitles.size()); // final Entry<SubtitleFile, SubtitleFormat> loaded = subtitles.entrySet().iterator().next(); // assertEquals(subtitleFile, loaded.getKey()); // assertEquals(subtitleFormat, loaded.getValue()); }
/** * Unpacks a jar file to a temporary directory that will be removed when the VM exits. * * @param jarfilePath the path of the jar to unpack * @return the path of the temporary directory */ private static String explodeJarToTempDir(File jarfilePath) { try { final Path jarfileDir = Files.createTempDirectory(jarfilePath.getName()); Runtime.getRuntime() .addShutdownHook( new Thread() { @Override public void run() { delete(jarfileDir.toFile()); } }); jarfileDir.toFile().deleteOnExit(); JarFile jarfile = new JarFile(jarfilePath); Enumeration<JarEntry> entries = jarfile.entries(); while (entries.hasMoreElements()) { JarEntry e = entries.nextElement(); if (!e.isDirectory()) { File path = new File(jarfileDir.toFile(), e.getName().replace('/', File.separatorChar)); File dir = path.getParentFile(); dir.mkdirs(); assert dir.exists(); Files.copy(jarfile.getInputStream(e), path.toPath()); } } return jarfileDir.toFile().getAbsolutePath(); } catch (IOException e) { throw new AssertionError(e); } }
@Test public void testRemoveAttachment() throws Exception { // CREATING ATTACHMENT FOR REMOVE List<MultipartFile> files = new ArrayList<>(); files.add(multipartFile); Mockito.when(attachmentFactory.newAttachment()).thenReturn(null); attachmentService.setAttachment(new Attachment()); attachmentService.setMessageResponse(new MessageResponse()); MessageResponse messageResponse1 = attachmentService.createAttachment(files); Mockito.verify(attachmentDao, Mockito.times(1)).createAttachments(argumentCaptor.capture()); Attachment attachment = argumentCaptor.getValue().get(0); // REMOVE ATTACHMENT Mockito.when(attachmentDao.removeAttachment(attachment.getAttachmentId())) .thenReturn(attachment); MessageResponse messageResponse = attachmentService.removeAttachment(attachment.getAttachmentId()); boolean isExistPreview = Files.exists(Paths.get(storagePath + attachment.getPreviewPath())); boolean isExistImage = Files.exists(Paths.get(storagePath + attachment.getFilePathInStorage())); Assert.assertTrue(!isExistPreview && !isExistImage && messageResponse.getCode() == 1); }
public void drop() throws Exception { for (int i = 0; i < 16; i++) { File subDir = new File(mainDir, String.valueOf(i) + ".dir"); for (int j = 0; j < 16; j++) { if (databases[i][j] != null) { File dbFile = new File(subDir, String.valueOf(j) + ".dat"); if (dbFile.exists()) { try { Files.delete(dbFile.toPath()); } catch (SecurityException | IOException e) { throw new Exception("Access violation: cannon delete database file"); } } } } if (subDir.exists()) { try { Files.delete(subDir.toPath()); } catch (DirectoryNotEmptyException e) { throw new Exception("Cannot remove table subdirectory. Redundant files"); } catch (SecurityException | IOException e) { throw new Exception("Access violation: cannot delete database subdirectory"); } } } try { Files.delete(mainDir.toPath()); } catch (DirectoryNotEmptyException e) { throw new Exception("Cannot remove main table directory. Redundant files"); } catch (SecurityException | IOException e) { throw new Exception("Access violation: cannot delete main database directory"); } }
@Override public Path getCommandPath(Path command) { if (command.isAbsolute()) { return command; } if (Platform.getOS().equals(Platform.OS_WIN32)) { if (!command.toString().endsWith(".exe")) { // $NON-NLS-1$ command = Paths.get(command.toString() + ".exe"); // $NON-NLS-1$ } } if (path != null) { for (Path p : path) { Path c = p.resolve(command); if (Files.isExecutable(c)) { return c; } } } // Look for it in the path environment var IEnvironmentVariable myPath = getVariable("PATH"); // $NON-NLS-1$ String path = myPath != null ? myPath.getValue() : System.getenv("PATH"); // $NON-NLS-1$ for (String entry : path.split(File.pathSeparator)) { Path entryPath = Paths.get(entry); Path cmdPath = entryPath.resolve(command); if (Files.isExecutable(cmdPath)) { return cmdPath; } } return null; }
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()); } }
private Path extractIfRequired(final Path buildDir) throws MojoFailureException, MojoExecutionException { if (jbossHome != null) { // we do not need to download WildFly return Paths.get(jbossHome); } final String artifact = ArtifactNameSplitter.of(this.artifact) .setArtifactId(artifactId) .setClassifier(classifier) .setGroupId(groupId) .setPackaging(packaging) .setVersion(version) .asString(); final Path result = artifactResolver.resolve(project, artifact).toPath(); final Path target = buildDir.resolve(WILDFLY_DIR); // Delete the target if it exists if (Files.exists(target)) { try { Archives.deleteDirectory(target); } catch (IOException e) { throw new MojoFailureException("Could not delete target directory: " + target, e); } } try { Archives.unzip(result, target); final Iterator<Path> iterator = Files.newDirectoryStream(target).iterator(); if (iterator.hasNext()) return iterator.next(); } catch (IOException e) { throw new MojoFailureException("Artifact was not successfully extracted: " + result, e); } throw new MojoFailureException("Artifact was not successfully extracted: " + result); }
@Test public void frameworkDependenciesDoNotContainTransitiveDependencies() throws Exception { assumeTrue(Platform.detect() == Platform.MACOS); assumeTrue(AppleNativeIntegrationTestUtils.isApplePlatformAvailable(ApplePlatform.MACOSX)); ProjectWorkspace workspace = TestDataHelper.createProjectWorkspaceForScenario( this, "apple_library_with_library_dependencies", tmp); workspace.setUp(); ProjectFilesystem filesystem = new ProjectFilesystem(workspace.getDestPath()); BuildTarget target = BuildTargetFactory.newInstance( "//Libraries/TestLibrary:TestLibrary#framework,macosx-x86_64"); ProjectWorkspace.ProcessResult result = workspace.runBuckCommand("build", target.getFullyQualifiedName()); result.assertSuccess(); Path frameworkPath = workspace.getPath( BuildTargets.getGenPath( filesystem, BuildTarget.builder(target) .addFlavors(AppleDebugFormat.DWARF.getFlavor()) .addFlavors(AppleDescriptions.INCLUDE_FRAMEWORKS_FLAVOR) .build(), "%s") .resolve("TestLibrary.framework")); assertThat(Files.exists(frameworkPath), is(true)); Path frameworksPath = frameworkPath.resolve("Frameworks"); assertThat(Files.exists(frameworksPath), is(true)); Path depFrameworksPath = frameworksPath.resolve("TestLibraryDep.framework/Frameworks"); assertThat(Files.exists(depFrameworksPath), is(false)); }
@Test public void noIncludeFrameworksDoesntContainFrameworkDependencies() throws Exception { assumeTrue(Platform.detect() == Platform.MACOS); assumeTrue(AppleNativeIntegrationTestUtils.isApplePlatformAvailable(ApplePlatform.MACOSX)); ProjectWorkspace workspace = TestDataHelper.createProjectWorkspaceForScenario( this, "apple_library_with_library_dependencies", tmp); workspace.setUp(); ProjectFilesystem filesystem = new ProjectFilesystem(workspace.getDestPath()); BuildTarget target = BuildTargetFactory.newInstance( "//Libraries/TestLibrary:TestLibrary#" + "dwarf-and-dsym,framework,macosx-x86_64,no-include-frameworks"); ProjectWorkspace.ProcessResult result = workspace.runBuckCommand("build", target.getFullyQualifiedName()); result.assertSuccess(); Path frameworkPath = workspace.getPath( BuildTargets.getGenPath(filesystem, target, "%s").resolve("TestLibrary.framework")); assertThat(Files.exists(frameworkPath), is(true)); assertThat(Files.exists(frameworkPath.resolve("Resources/Info.plist")), is(true)); Path libraryPath = frameworkPath.resolve("TestLibrary"); assertThat(Files.exists(libraryPath), is(true)); assertThat( workspace.runCommand("file", libraryPath.toString()).getStdout().get(), containsString("dynamically linked shared library")); Path frameworksPath = frameworkPath.resolve("Contents/Frameworks"); assertThat(Files.exists(frameworksPath), is(false)); }
@Test public void testAppleDynamicLibraryWithDsym() throws Exception { assumeTrue(Platform.detect() == Platform.MACOS); assumeTrue(AppleNativeIntegrationTestUtils.isApplePlatformAvailable(ApplePlatform.MACOSX)); ProjectWorkspace workspace = TestDataHelper.createProjectWorkspaceForScenario(this, "apple_library_shared", tmp); workspace.setUp(); ProjectFilesystem filesystem = new ProjectFilesystem(workspace.getDestPath()); ProjectWorkspace.ProcessResult result = workspace.runBuckCommand( "build", "//Libraries/TestLibrary:TestLibrary#shared,macosx-x86_64,dwarf-and-dsym", "--config", "cxx.cflags=-g"); result.assertSuccess(); Path output = tmp.getRoot() .resolve(filesystem.getBuckPaths().getGenDir()) .resolve("Libraries/TestLibrary/TestLibrary#macosx-x86_64,shared") .resolve("libLibraries_TestLibrary_TestLibrary.dylib"); assertThat(Files.exists(output), is(true)); Path dsymPath = tmp.getRoot() .resolve(filesystem.getBuckPaths().getGenDir()) .resolve("Libraries/TestLibrary") .resolve("TestLibrary#apple-dsym,macosx-x86_64,shared.dSYM"); assertThat(Files.exists(dsymPath), is(true)); AppleDsymTestUtil.checkDsymFileHasDebugSymbol("+[TestClass answer]", workspace, dsymPath); }
@Test public void testAppleLibraryBuildsFramework() throws Exception { assumeTrue(Platform.detect() == Platform.MACOS); assumeTrue(AppleNativeIntegrationTestUtils.isApplePlatformAvailable(ApplePlatform.MACOSX)); ProjectWorkspace workspace = TestDataHelper.createProjectWorkspaceForScenario( this, "apple_library_builds_something", tmp); workspace.setUp(); ProjectFilesystem filesystem = new ProjectFilesystem(workspace.getDestPath()); BuildTarget target = BuildTargetFactory.newInstance( "//Libraries/TestLibrary:TestLibrary#framework,macosx-x86_64,no-debug"); ProjectWorkspace.ProcessResult result = workspace.runBuckCommand("build", target.getFullyQualifiedName()); result.assertSuccess(); Path frameworkPath = workspace.getPath( BuildTargets.getGenPath( filesystem, BuildTarget.builder(target) .addFlavors(AppleDescriptions.INCLUDE_FRAMEWORKS_FLAVOR) .build(), "%s") .resolve("TestLibrary.framework")); assertThat(Files.exists(frameworkPath), is(true)); assertThat(Files.exists(frameworkPath.resolve("Resources/Info.plist")), is(true)); Path libraryPath = frameworkPath.resolve("TestLibrary"); assertThat(Files.exists(libraryPath), is(true)); assertThat( workspace.runCommand("file", libraryPath.toString()).getStdout().get(), containsString("dynamically linked shared library")); }
/** Start the logging system. We must define a new log to store everything. */ public synchronized void createLog() { if (logPath == null) { String id = String.format("log_%d", System.currentTimeMillis()); try { // Try to close the old channel. if (logChannel != null) { logChannel.close(); } logPath = Paths.get(db.getLogPath() + System.getProperty("file.separator") + id).toAbsolutePath(); if (!Files.exists(logPath)) { // Create the necessary parent directories. Files.createDirectories(Paths.get(db.getLogPath()).toAbsolutePath()); // Make sure that our WAL is created before we return. logPath = Files.createFile(logPath); // Open up the line of communication. String flag = "rw"; if (flushPolicy == Flush.SAFE) { flag += "d"; } logChannel = new RandomAccessFile(logPath.toString(), flag).getChannel(); // Map the file. logBuffer = mapWAL(); } } catch (IOException e) { e.printStackTrace(); } catch (Exception e) { e.printStackTrace(); } } }
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 static Path storeInTemp(String pluginName, InputStream in, SitePaths sitePaths) throws IOException { if (!Files.exists(sitePaths.tmp_dir)) { Files.createDirectories(sitePaths.tmp_dir); } return asTemp(in, tempNameFor(pluginName), ".jar", sitePaths.tmp_dir); }
public void event(WatchEvent.Kind kind, Path path) { // System.out.println("Log event"); File file = new File(path.toString()); String ip = "0.0.0.0", owner = "unknown"; try { ip = Inet4Address.getLocalHost().getHostAddress(); } catch (UnknownHostException e) { e.printStackTrace(); } try { FileOwnerAttributeView ownerAttributeView = Files.getFileAttributeView(path, FileOwnerAttributeView.class); owner = ownerAttributeView.getOwner().getName(); } catch (IOException e) { e.printStackTrace(); } String entry = String.format( "[%s] \"%s\" copied on \"%s\" by \"%s\"\n", new SimpleDateFormat("dd/MMM/YYYY HH:mm:ss").format(new Date()), path.toString(), ip, owner); try { Files.write(Paths.get(logFile), entry.getBytes(), StandardOpenOption.APPEND); } catch (IOException e) { e.printStackTrace(); } }
@Override public Item item(final QueryContext qc, final InputInfo ii) throws QueryException { checkCreate(qc); final Path path = toPath(0, qc); final B64 archive = toB64(exprs[1], qc, false); final TokenSet hs = entries(2, qc); try (ArchiveIn in = ArchiveIn.get(archive.input(info), info)) { while (in.more()) { final ZipEntry ze = in.entry(); final String name = ze.getName(); if (hs == null || hs.delete(token(name)) != 0) { final Path file = path.resolve(name); if (ze.isDirectory()) { Files.createDirectories(file); } else { Files.createDirectories(file.getParent()); Files.write(file, in.read()); } } } } catch (final IOException ex) { throw ARCH_FAIL_X.get(info, ex); } return null; }
private static void pathesAndFileCreation() throws IOException { System.out.println("yes\\no"); System.out.println("c:\\program files\\myProgram"); System.out.println("c:/program files/myProgram"); String win = "c:\\HaxLogs.txt"; String unix = "c:/HaxLogs.txt"; File winFile = new File(win); System.out.println("win file exists: " + winFile.exists()); File unixFile = new File(unix); System.out.println("unix file exists: " + unixFile.exists()); Path path = Paths.get("myFile.txt"); System.out.println(path); System.out.println(path.toAbsolutePath()); Path absolutePath = Paths.get("d:/myFile.txt"); System.out.println(absolutePath); System.out.println(absolutePath.toAbsolutePath()); if (!Files.exists(absolutePath)) { Files.createFile(absolutePath); System.out.println("file created"); } else { System.out.println("file already exists"); } }
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 Boolean isCollectorFullBase() throws BotException { final int[] attackableElixirs = {0}; final BufferedImage image = platform.screenshot(ENEMY_BASE); try { final URI uri = getClass().getResource("elixirs").toURI(); Utils.withClasspathFolder( uri, (path) -> { final List<Rectangle> matchedElixirs = new ArrayList<>(); try (Stream<Path> walk = Files.walk(path, 1)) { for (final Iterator<Path> it = walk.iterator(); it.hasNext(); ) { final Path next = it.next(); if (Files.isDirectory(next)) { continue; } final BufferedImage tar = ImageIO.read(Files.newInputStream(next, StandardOpenOption.READ)); final List<RegionMatch> doFindAll = TemplateMatcher.findMatchesByGrayscaleAtOriginalResolution(image, tar, 7, 0.8); attackableElixirs[0] += countAttackableElixirs(doFindAll, matchedElixirs, next); } } catch (final IOException e) { logger.log(Level.SEVERE, e.getMessage(), e); } }); } catch (final URISyntaxException e) { logger.log(Level.SEVERE, e.getMessage(), e); } return attackableElixirs[0] >= 0; }
private void moveCorruptedReplayFile(Path replayFile) throws IOException { Path corruptedReplaysDirectory = preferencesService.getCorruptedReplaysDirectory(); Files.createDirectories(corruptedReplaysDirectory); Path target = corruptedReplaysDirectory.resolve(replayFile.getFileName()); logger.debug("Moving corrupted replay file from {} to {}", replayFile, target); Files.move(replayFile, target); notificationService.addNotification( new PersistentNotification( i18n.get("corruptedReplayFiles.notification"), Severity.WARN, Collections.singletonList( new Action( i18n.get("corruptedReplayFiles.show"), event -> { try { // Argh, using AWT since JavaFX doesn't provide a proper method :-( Desktop.getDesktop().open(corruptedReplaysDirectory.toFile()); } catch (IOException e) { logger.warn("Could not reveal corrupted replay directory", e); } })))); }
/** * Check uploading files and create attachments * * @throws Exception */ @Test public void testCreateAttachment() throws Exception { List<MultipartFile> files = new ArrayList<>(); files.add(multipartFile); Mockito.when(attachmentFactory.newAttachment()).thenReturn(null); attachmentService.setAttachment(new Attachment()); attachmentService.setMessageResponse(new MessageResponse()); MessageResponse messageResponse = attachmentService.createAttachment(files); Mockito.verify(attachmentDao, Mockito.times(1)).createAttachments(argumentCaptor.capture()); Attachment attachment = argumentCaptor.getValue().get(0); boolean isExistPreview = Files.exists(Paths.get(storagePath + attachment.getPreviewPath())); boolean isExistImage = Files.exists(Paths.get(storagePath + attachment.getFilePathInStorage())); Files.delete(Paths.get(storagePath + attachment.getPreviewPath())); Files.delete(Paths.get(storagePath + attachment.getFilePathInStorage())); Assert.assertTrue( attachment.getMimeType().equals("image/png") && messageResponse.getCode() == 0 && isExistPreview && isExistImage); }
@Test public void testDeleteInstanceDirAfterCreateFailure() throws Exception { assumeFalse( "Ignore test on windows because it does not delete data directory immediately after unload", Constants.WINDOWS); File solrHomeDirectory = new File(initCoreDataDir, getClass().getName() + "-corex-" + System.nanoTime()); solrHomeDirectory.mkdirs(); copySolrHomeToTemp(solrHomeDirectory, "corex"); File corex = new File(solrHomeDirectory, "corex"); FileUtils.write(new File(corex, "core.properties"), "", StandardCharsets.UTF_8); JettySolrRunner runner = new JettySolrRunner(solrHomeDirectory.getAbsolutePath(), buildJettyConfig("/solr")); runner.start(); try (HttpSolrClient client = getHttpSolrClient(runner.getBaseUrl() + "/corex")) { client.setConnectionTimeout(SolrTestCaseJ4.DEFAULT_CONNECTION_TIMEOUT); client.setSoTimeout(SolrTestCaseJ4.DEFAULT_CONNECTION_TIMEOUT); SolrInputDocument doc = new SolrInputDocument(); doc.addField("id", "123"); client.add(doc); client.commit(); } Path dataDir = null; try (HttpSolrClient client = getHttpSolrClient(runner.getBaseUrl().toString())) { CoreStatus status = CoreAdminRequest.getCoreStatus("corex", true, client); String dataDirectory = status.getDataDirectory(); dataDir = Paths.get(dataDirectory); assertTrue(Files.exists(dataDir)); } File subHome = new File(solrHomeDirectory, "corex" + File.separator + "conf"); String top = SolrTestCaseJ4.TEST_HOME() + "/collection1/conf"; FileUtils.copyFile( new File(top, "bad-error-solrconfig.xml"), new File(subHome, "solrconfig.xml")); try (HttpSolrClient client = getHttpSolrClient(runner.getBaseUrl().toString())) { client.setConnectionTimeout(SolrTestCaseJ4.DEFAULT_CONNECTION_TIMEOUT); client.setSoTimeout(SolrTestCaseJ4.DEFAULT_CONNECTION_TIMEOUT); try { CoreAdminRequest.reloadCore("corex", client); } catch (Exception e) { // this is expected because we put a bad solrconfig -- ignore } CoreAdminRequest.Unload req = new CoreAdminRequest.Unload(false); req.setDeleteDataDir(true); req.setDeleteInstanceDir( false); // important because the data directory is inside the instance directory req.setCoreName("corex"); req.process(client); } runner.stop(); assertTrue( "The data directory was not cleaned up on unload after a failed core reload", Files.notExists(dataDir)); }
@After public void tearDown() throws Exception { // Удаляем тестовый фаил Files.delete(Paths.get(pathTempFile)); // Удаляем тестовые папки и файлы Files.walkFileTree( Paths.get(storagePath), new SimpleFileVisitor<Path>() { @Override public FileVisitResult visitFile(Path file, BasicFileAttributes attrs) throws IOException { Files.delete(file); return FileVisitResult.CONTINUE; } @Override public FileVisitResult postVisitDirectory(Path dir, IOException exc) throws IOException { Files.delete(dir); return FileVisitResult.CONTINUE; } }); }
@Before public void setUp() throws Exception { deleteDirectoryIfExists(DIRECTORY); deleteDirectoryIfExists(DIRECTORY2); Files.createDirectory(DIRECTORY); Files.createDirectory(DIRECTORY2); }
private List<Future<?>> loadSavedMetricsToCaches(String accessLevelName) { String storage = metricStorage + "/" + accessLevelName; Path storageFile = Paths.get(storage); if (!Files.exists(storageFile)) { log.info("Cannot pre-load cache {} - file {} doesn't exist", accessLevelName, storage); return Collections.emptyList(); } try (BufferedReader fromStorageFile = new BufferedReader( new InputStreamReader( new GZIPInputStream(Files.newInputStream(storageFile)), Charset.forName("UTF-8")))) { boolean firstLine = true; String metricName; List<Future<?>> futures = new ArrayList<>(); while ((metricName = fromStorageFile.readLine()) != null) { if (firstLine) { firstLine = false; } else { futures.add(createNewCacheLines(metricName)); } } return futures; } catch (IOException e) { log.info("could not find file for accessLevel " + accessLevelName, e); return Collections.emptyList(); } }
@Test public void backupComplexDir() throws IOException { Path dirToBkp = Files.createTempDirectory("dirToBkp4"); Path subDir1 = Files.createTempDirectory(dirToBkp, "subDir1"); Path subDir2 = Files.createTempDirectory(dirToBkp, "subDir2"); Path subDir3 = Files.createTempDirectory(subDir1, "subDir3"); Path parentdirfile1 = createTempFile(dirToBkp, "FILE_1", ".tmp"); Path parentdirfile2 = createTempFile(subDir1, "FILE_2", ".tmp"); Path parentdirfile3 = createTempFile(subDir3, "FILE_3", ".tmp"); new BackupHelper(conf).backupFileOrDir(dirToBkp); Path bkp = PathUtils.get(conf.getBackupDir(), dirToBkp); assertThat(exists(bkp), is(true)); assertThat(exists(PathUtils.get(bkp, parentdirfile1.getFileName())), is(true)); assertThat(exists(PathUtils.get(bkp, subDir1.getFileName())), is(true)); assertThat(exists(PathUtils.get(bkp, subDir2.getFileName())), is(true)); assertThat( exists( PathUtils.get(PathUtils.get(bkp, subDir1.getFileName()), parentdirfile2.getFileName())), is(true)); assertThat( exists(PathUtils.get(PathUtils.get(bkp, subDir1.getFileName()), subDir3.getFileName())), is(true)); assertThat( exists( PathUtils.get( PathUtils.get(PathUtils.get(bkp, subDir1.getFileName()), subDir3.getFileName()), parentdirfile3.getFileName())), is(true)); }
public void split() throws IOException { List<ObjectPath> pathTable = asset.getPaths(); TypeTree typeTree = asset.getTypeTree(); // assets with just one object can't be split any further if (pathTable.size() == 1) { L.warning("Asset doesn't contain sub-assets!"); return; } for (ObjectPath path : pathTable) { // skip filtered classes if (cf != null && !cf.accept(path)) { continue; } String className = ClassID.getNameForID(path.getClassID(), true); AssetFile subAsset = new AssetFile(); subAsset.getHeader().setFormat(asset.getHeader().getFormat()); ObjectPath subFieldPath = new ObjectPath(); subFieldPath.setClassID1(path.getClassID1()); subFieldPath.setClassID2(path.getClassID2()); subFieldPath.setLength(path.getLength()); subFieldPath.setOffset(0); subFieldPath.setPathID(1); subAsset.getPaths().add(subFieldPath); TypeTree subTypeTree = subAsset.getTypeTree(); subTypeTree.setEngineVersion(typeTree.getEngineVersion()); subTypeTree.setVersion(-2); subTypeTree.setFormat(typeTree.getFormat()); subTypeTree.getFields().put(path.getClassID(), typeTree.getFields().get(path.getClassID())); subAsset.setDataBuffer(asset.getPathBuffer(path)); Path subAssetDir = outputDir.resolve(className); if (Files.notExists(subAssetDir)) { Files.createDirectories(subAssetDir); } // probe asset name String subAssetName = getObjectName(asset, path); if (subAssetName != null) { // remove any chars that could cause troubles on various file systems subAssetName = FilenameSanitizer.sanitizeName(subAssetName); } else { // use numeric names subAssetName = String.format("%06d", path.getPathID()); } subAssetName += ".asset"; Path subAssetFile = subAssetDir.resolve(subAssetName); if (Files.notExists(subAssetFile)) { L.log(Level.INFO, "Writing {0}", subAssetFile); subAsset.save(subAssetFile); } } }
public static Task createDownloadTask( ApiSession sess, String servicename, Path local, CommonPath remote, Struct storeParams, boolean allowResume) { DownloadFile work = new DownloadFile(); work.session = sess; RecordStruct params = new RecordStruct( new FieldStruct("LocalPath", local), new FieldStruct("RemotePath", remote), new FieldStruct("ServiceName", servicename), new FieldStruct("TransferParams", storeParams)); if (allowResume && Files.exists(local)) { try { params.setField("Offset", Files.size(local)); } catch (IOException x) { Logger.error("Unable to get file size for: " + local); return null; } } return new Task() .withTitle("Download file " + local) .withWork(work) .withSubContext() .withParams(params) .withTimeout(1) .withDeadline(0); }