@Override public void download(String remote, Path local, Collection<Option> options) throws IOException { local = ValidateUtils.checkNotNull(local, "Invalid argument local: %s", local); remote = ValidateUtils.checkNotNullAndNotEmpty(remote, "Invalid argument remote: %s", remote); LinkOption[] opts = IoUtils.getLinkOptions(false); if (Files.isDirectory(local, opts)) { options = addTargetIsDirectory(options); } if (options.contains(Option.TargetIsDirectory)) { Boolean status = IoUtils.checkFileExists(local, opts); if (status == null) { throw new SshException("Target directory " + local.toString() + " is probaly inaccesible"); } if (!status.booleanValue()) { throw new SshException("Target directory " + local.toString() + " does not exist"); } if (!Files.isDirectory(local, opts)) { throw new SshException("Target directory " + local.toString() + " is not a directory"); } } download(remote, local.getFileSystem(), local, options); }
/** * Loads up a set of {@link IridaWorkflow}s from the given directory. * * @param workflowDirectory The directory containing the different workflow implementations and * files. * @return A set of {@link IridaWorkflow}s for all implementations. * @throws IOException If there was an issue reading one of the workflow files. * @throws IridaWorkflowLoadException If there was an issue when loading up the workflows. */ public Set<IridaWorkflow> loadAllWorkflowImplementations(Path workflowDirectory) throws IOException, IridaWorkflowLoadException { checkNotNull(workflowDirectory, "workflowDirectory is null"); checkArgument(Files.isDirectory(workflowDirectory), "workflowDirectory is not a directory"); Set<IridaWorkflow> workflowImplementations = new HashSet<>(); DirectoryStream<Path> stream = Files.newDirectoryStream(workflowDirectory); for (Path implementationDirectory : stream) { if (!Files.isDirectory(implementationDirectory)) { logger.warn( "Workflow directory " + workflowDirectory + " contains a file " + implementationDirectory + " that is not a proper workflow directory"); } else { IridaWorkflow iridaWorkflow = loadIridaWorkflowFromDirectory(implementationDirectory); workflowImplementations.add(iridaWorkflow); } } return workflowImplementations; }
/** * Collects the files from given directory if it exists. Files will be sorted by name. * * @param migrationPath Path * @return Sorted files * @throws IOException If directory stream fails */ private List<Path> getMigrationFiles(Path migrationPath) throws IOException { if ((null == migrationPath) || !Files.exists(migrationPath) || !Files.isDirectory(migrationPath)) { return Collections.emptyList(); } // get directory stream and add all files DirectoryStream<Path> directoryStream = Files.newDirectoryStream(migrationPath); List<Path> migrationsFiles = new ArrayList<>(); for (Path migrationFile : directoryStream) { if (!Files.isDirectory(migrationFile)) { migrationsFiles.add(migrationFile); } } // sort by name Collections.sort( migrationsFiles, new Comparator<Path>() { @Override public int compare(Path o1, Path o2) { return o1.getFileName().toString().compareTo(o2.getFileName().toString()); } }); return migrationsFiles; }
private void initHomeDir() throws IOException { String[] filesToCheck = new String[] {"logs", "tmp", "log4j.xml", "templates"}; if (!Files.exists(config.getHomeDir())) { Files.createDirectories(config.getHomeDir()); } if (Files.exists(config.getHomeDir()) && Files.isDirectory(config.getHomeDir())) { for (String fileToCheck : filesToCheck) { Path sourceFile = config.getResourceFetcher().getFile(fileToCheck); if (sourceFile != null && Files.exists(sourceFile)) { Path destFile = config.getHomeDir().resolve(fileToCheck); if (!Files.exists(destFile)) { if (Files.isDirectory(sourceFile)) { Files.createDirectories(destFile); for (Path f : PathUtils.list(sourceFile)) { if (Files.isDirectory(f)) { Path destDir2 = destFile.resolve(f.getFileName().toString()); for (Path x : PathUtils.list(f)) { FileUtils.copyFile( x.toFile(), destDir2.resolve(x.getFileName().toString()).toFile()); } } else if (Files.isDirectory(f)) { FileUtils.copyFile( f.toFile(), destFile.resolve(f.getFileName().toString()).toFile()); } } } else { FileUtils.copyFile(sourceFile.toFile(), destFile.toFile()); } } } } } }
@Override public Stream<Entry> entries() { List<Entry> entries = new ArrayList<>(); try { /* * This code should be revisited to avoid buffering of the entries. * 1) Do we really need sorting classes? This force buffering of entries. * libs, cmds and configs are not sorted. * 2) I/O streams should be concatenated instead of buffering into * entries list. * 3) Close I/O streams in a close handler. */ if (classes != null) { try (Stream<Path> stream = Files.walk(classes)) { entries.addAll( stream .filter( p -> !Files.isDirectory(p) && !classes.relativize(p).toString().startsWith("_the.") && !classes.relativize(p).toString().equals("javac_state")) .sorted() .map(p -> toEntry(p, classes, EntryType.CLASS_OR_RESOURCE)) .collect(Collectors.toList())); } } if (cmds != null) { try (Stream<Path> stream = Files.walk(cmds)) { entries.addAll( stream .filter(p -> !Files.isDirectory(p)) .map(p -> toEntry(p, cmds, EntryType.NATIVE_CMD)) .collect(Collectors.toList())); } } if (libs != null) { try (Stream<Path> stream = Files.walk(libs)) { entries.addAll( stream .filter(p -> !Files.isDirectory(p)) .map(p -> toEntry(p, libs, EntryType.NATIVE_LIB)) .collect(Collectors.toList())); } } if (configs != null) { try (Stream<Path> stream = Files.walk(configs)) { entries.addAll( stream .filter(p -> !Files.isDirectory(p)) .map(p -> toEntry(p, configs, EntryType.CONFIG)) .collect(Collectors.toList())); } } } catch (IOException ioe) { throw new UncheckedIOException(ioe); } return entries.stream(); }
private void restoreBackup(Path copy, Path original) throws IOException { if (Files.exists(copy) && Files.isDirectory(copy)) { FileUtils.deleteQuietly(original.toFile()); FileUtils.moveDirectory(copy.toFile(), original.toFile()); } else if (Files.exists(copy) && !Files.isDirectory(copy)) { FileUtils.deleteQuietly(original.toFile()); FileUtils.moveFile(copy.toFile(), original.toFile()); } }
@Override public void onWebSocketConnect(Session sess) { connected = true; final String spath = getFirstValue(sess, "path"); final String sset = getFirstValue(sess, "dataset"); final boolean writing = Boolean.parseBoolean(getFirstValue(sess, "writingExpected")); final Path path = Paths.get(spath); try { WatchService myWatcher = path.getFileSystem().newWatchService(); QueueReader fileWatcher = new QueueReader(myWatcher, sess, spath, sset, writing); // We may only monitor a directory if (Files.isDirectory(path)) { path.register(myWatcher, ENTRY_CREATE, ENTRY_MODIFY, ENTRY_DELETE); } else { path.getParent().register(myWatcher, ENTRY_CREATE, ENTRY_MODIFY, ENTRY_DELETE); } Thread th = new Thread(fileWatcher, path.getFileName() + " Watcher"); th.setDaemon(true); th.setPriority(Thread.MAX_PRIORITY - 2); th.start(); if (diagInfo != null) diagInfo.record("Start Thread", th.getName()); } catch (Exception ne) { logger.error("Cannot watch " + path, ne); try { sess.getRemote().sendString(ne.getMessage()); } catch (IOException e) { logger.warn("Cannot write to remote " + sess, e); } } }
private Toolbox loadToolbox() throws IOException, URISyntaxException { Path foundPath = findToolsDir(); Toolbox box; if (Files.isDirectory(foundPath)) { box = new Toolbox(foundPath); Path tempDir = Files.createTempDirectory(TOOLS_DIR_NAME); Path tempZipFile = tempDir.resolve(TOOLS_ZIP_NAME); dirToZip(foundPath, tempZipFile); byte[] zipContents = Files.readAllBytes(tempZipFile); box.setZipContents(zipContents); Files.delete(tempZipFile); Files.delete(tempDir); } // found tools zip else { FileSystem fs = FileSystems.newFileSystem(foundPath, null); Path toolsPath = fs.getPath(TOOLS_DIR_NAME); box = new Toolbox(toolsPath); byte[] zipContents = Files.readAllBytes(foundPath); box.setZipContents(zipContents); } return box; }
protected void renameFile(SyncWatchEvent syncWatchEvent) throws Exception { Path sourceFilePath = Paths.get(syncWatchEvent.getPreviousFilePathName()); SyncFile syncFile = SyncFileService.fetchSyncFile(sourceFilePath.toString()); Path targetFilePath = Paths.get(syncWatchEvent.getFilePathName()); if (sanitizeFileName(targetFilePath)) { return; } if (syncFile == null) { if (Files.isDirectory(targetFilePath)) { addFolder(syncWatchEvent); } else { addFile(syncWatchEvent); } return; } else if (isPendingTypePK(syncFile)) { queueSyncWatchEvent(syncFile.getFilePathName(), syncWatchEvent); return; } String fileType = syncFile.getType(); if (fileType.equals(SyncFile.TYPE_FILE)) { SyncFileService.renameFileSyncFile(targetFilePath, _syncAccountId, syncFile); } else { SyncFileService.renameFolderSyncFile(targetFilePath, _syncAccountId, syncFile); } }
private ClientDatabase getConfigDatabase() { try { Path configDir = databaseFile.toAbsolutePath().getParent(); if (!Files.isDirectory(configDir)) { Files.createDirectory(configDir); } connection = DriverManager.getConnection(getSqliteConnectionString()); try { try (Statement statement = connection.createStatement()) { statement.execute("PRAGMA FOREIGN_KEYS = ON"); } ClientDatabase clientDatabase = new ChatClientDatabase(connection); clientDatabase.migrate(); return clientDatabase; } catch (Exception e) { try { connection.close(); } catch (Exception ignored) { } throw e; } } catch (Exception e) { throw new IllegalStateException( "failed to initialize or migrate config database:" + e.getMessage(), e); } }
public static FileInfo pathToFileInfo(Path filePath, Path start) { FileInfo fileInfo = new FileInfo(); if (!Files.exists(filePath)) { fileInfo.setName("Unknown"); return fileInfo; } fileInfo.setName(start.relativize(filePath).toString()); if (Files.isDirectory(filePath)) { fileInfo.setDir(true); } else { fileInfo.setDir(false); try { fileInfo.setSize(Files.size(filePath)); } catch (IOException e) { fileInfo.setSize(0); } try { fileInfo.setMimeType(Files.probeContentType(filePath)); } catch (IOException e) { fileInfo.setMimeType("application/octet-stream"); } if (fileInfo.getMimeType() == null) { fileInfo.setMimeType("application/octet-stream"); } } return fileInfo; }
@GenerateLink(rel = Constants.LINK_REL_GET_CURRENT_RECIPE) @GET @Path("/recipe") @Produces(MediaType.APPLICATION_JSON) public Response getRecipe(@QueryParam("id") String id) throws Exception { java.nio.file.Path dockerParentPath = Paths.get(dockerfilesRepository); if (dockerfilesRepository == null || !java.nio.file.Files.exists(dockerParentPath) || !java.nio.file.Files.isDirectory(dockerParentPath)) { throw new NotFoundException( "The configuration of docker repository wasn't found or some problem with configuration was found."); } final String path = id.replace(SYSTEM_PREFIX, "") + DOCKER_FILE_NAME; java.nio.file.Path dockerFile = Paths.get(dockerParentPath.toAbsolutePath().toString(), path); if (!java.nio.file.Files.exists(dockerFile)) { throw new NotFoundException("The docker file with given id wasn't found."); } return Response.ok( "{ \"recipe\":\"" + new String(java.nio.file.Files.readAllBytes(dockerFile)) + "\" }", MediaType.APPLICATION_JSON_TYPE) .build(); }
@Test public void test() throws Exception { Module module = new Module( "test", new Version("1.0.0", new LiquibaseMigration(), new AntMigration("test-ant_1.0.0.xml"))); Connection conn = DriverManager.getConnection("jdbc:h2:mem:test", "sa", "sa"); Path path = Paths.get("solidbase-test-dir"); try { Solidbase solidbase = new Solidbase(); solidbase.migrate( conn, Thread.currentThread().getContextClassLoader(), new H2Database(), module); Integer count = selectIntFromDatabase(conn, "SELECT COUNT(*) FROM PERSON"); assertEquals(0, count.intValue()); String version = selectStringFromDatabase(conn, "SELECT VERSION FROM VERSIONS WHERE MODULE_ID='test'"); assertEquals("1.0.0", version); assertTrue(Files.exists(path)); assertTrue(Files.isDirectory(path)); } finally { ignoreException(() -> conn.close()); ignoreException(() -> Files.delete(path)); } }
public static void saveData(String file, EnumMap<PlayerStats, Float> map, boolean overwrite) { FileSystem fileSystem = FileSystems.getDefault(); Path path = fileSystem.getPath(file); if (Files.isDirectory(path)) throw new IllegalArgumentException("This method is not supposed to read a directory"); if (Files.exists(path) && Files.isReadable(path)) { if (overwrite == false) return; } else try { Files.createFile(path); } catch (IOException e) { e .printStackTrace(); // To change body of catch statement use File | Settings | File // Templates. } try (ObjectOutputStream objectOutputStream = new ObjectOutputStream(Files.newOutputStream(path))) { objectOutputStream.writeObject(map); } catch (IOException e) { e .printStackTrace(); // To change body of catch statement use File | Settings | File // Templates. } }
/** * Marshals the object to the given path that must represent a path to the file. * * <p>This method is capable of setting the schema version to the object being marshalled. * * @param path Path to file * @param object Object to marshal * @param noNamespaceSchemaLocation NoNamespaceSchemaLocation to set. If it's <code>null</code> no * location will be set. * @param schemaVersion If schema version is set and object to marshall is instance of {@link * ISchemaVersionAware} then the given schema version will be set to the object. Use <code>0 * </code> to ignore setting of schema version. * @throws JAXBException If {@link JAXBException} occurs. * @throws IOException If {@link IOException} occurs. */ public void marshall( Path path, Object object, String noNamespaceSchemaLocation, int schemaVersion) throws JAXBException, IOException { if (Files.isDirectory(path)) { throw new IOException("Can not marshal object to the path that represents the directory"); } Files.deleteIfExists(path); Files.createDirectories(path.getParent()); JAXBContext context = JAXBContext.newInstance(object.getClass()); Marshaller marshaller = context.createMarshaller(); marshaller.setProperty(Marshaller.JAXB_FORMATTED_OUTPUT, true); if (null != noNamespaceSchemaLocation) { marshaller.setProperty( Marshaller.JAXB_NO_NAMESPACE_SCHEMA_LOCATION, noNamespaceSchemaLocation); } // set schema version if needed if ((object instanceof ISchemaVersionAware) && (0 != schemaVersion)) { ((ISchemaVersionAware) object).setSchemaVersion(schemaVersion); } try (OutputStream outputStream = Files.newOutputStream(path, StandardOpenOption.CREATE_NEW)) { marshaller.marshal(object, outputStream); } }
/** * This is a best effort to ensure that we actually have write permissions to write in all our * data directories. This prevents disasters if nodes are started under the wrong username etc. */ private void assertCanWrite() throws IOException { for (Path path : nodeDataPaths()) { // check node-paths are writable tryWriteTempFile(path); } for (String indexFolderName : this.availableIndexFolders()) { for (Path indexPath : this.resolveIndexFolder(indexFolderName)) { // check index paths are writable Path indexStatePath = indexPath.resolve(MetaDataStateFormat.STATE_DIR_NAME); tryWriteTempFile(indexStatePath); tryWriteTempFile(indexPath); try (DirectoryStream<Path> stream = Files.newDirectoryStream(indexPath)) { for (Path shardPath : stream) { String fileName = shardPath.getFileName().toString(); if (Files.isDirectory(shardPath) && fileName.chars().allMatch(Character::isDigit)) { Path indexDir = shardPath.resolve(ShardPath.INDEX_FOLDER_NAME); Path statePath = shardPath.resolve(MetaDataStateFormat.STATE_DIR_NAME); Path translogDir = shardPath.resolve(ShardPath.TRANSLOG_FOLDER_NAME); tryWriteTempFile(indexDir); tryWriteTempFile(translogDir); tryWriteTempFile(statePath); tryWriteTempFile(shardPath); } } } } } }
private static Stream<String> apps() { if (cl instanceof URLClassLoader) { URLClassLoader ucl = (URLClassLoader) cl; return Stream.of(ucl.getURLs()) .map(propagating(url -> Paths.get(url.toURI()))) .flatMap( propagating( path -> { if (Files.isRegularFile(path)) { return zipContents(path); } else if (Files.isDirectory(path)) { return Files.walk(path) .map(subpath -> path.relativize(subpath)) .map(subpath -> subpath.toString()) .filter(subpath -> subpath.endsWith(".class")) .map(Scanner::toClassName); } else { return Stream.empty(); } })) .filter(x -> !x.startsWith("com.cakemanny.app.")) .filter(implementsInterface(App.class)); } else { return Stream.empty(); } }
/** * Returns list of files paths with given extension for a storage in HTTP form. * * @param storageData Storage. * @param extension Files extension. * @return Returns the map containing pair with file name with given extension for a storage in * HTTP form and size of each file. * @throws IOException If {@link IOException} occurs. */ public Map<String, Long> getFilesHttpLocation(StorageData storageData, final String extension) throws IOException { Path storagePath = getStoragePath(storageData); if (storagePath == null || !Files.isDirectory(storagePath)) { return Collections.emptyMap(); } final List<Path> filesPaths = new ArrayList<Path>(); Files.walkFileTree( storagePath, new SimpleFileVisitor<Path>() { @Override public FileVisitResult visitFile(Path file, BasicFileAttributes attrs) throws IOException { if (file.toString().endsWith(extension)) { filesPaths.add(file); } return super.visitFile(file, attrs); } }); Map<String, Long> result = new HashMap<String, Long>(); for (Path path : filesPaths) { result.put(getPathAsHttp(path), Files.size(path)); } return result; }
public static Collection<ProfileDef> getAvailableProfiles(Path rootDir) { Path profileDir = getProfileDirectory(rootDir); if (!Files.isDirectory(profileDir)) { return Collections.emptySet(); } List<ProfileDef> result = new LinkedList<>(); try (DirectoryStream<Path> profileDirContent = Files.newDirectoryStream(profileDir)) { int suffixLength = PROFILE_FILE_NAME_SUFFIX.length(); for (Path file : profileDirContent) { if (!Files.isRegularFile(file)) { continue; } String fileName = file.getFileName().toString(); String normFileName = fileName.toLowerCase(Locale.ROOT); if (!normFileName.endsWith(PROFILE_FILE_NAME_SUFFIX)) { continue; } // This should hold, but check it just in case I don't know // something about weird case issues. if (fileName.length() >= suffixLength) { String profileName = fileName.substring(0, fileName.length() - suffixLength); result.add(new ProfileDef(null, fileName, profileName)); } } } catch (IOException ex) { LOGGER.log(Level.INFO, "Cannot list profile directory: " + profileDir, ex); } return result; }
/** * Reads input files from input directory and sorts them in ascending order. * * @param inputDirPath input directory * @return sorted list of input files */ private static List<Path> getInputFiles(final Path inputDirPath) { final List<Path> result = new ArrayList<>(10); try (final DirectoryStream<Path> files = Files.newDirectoryStream(inputDirPath)) { final Iterator<Path> filesIterator = files.iterator(); while (filesIterator.hasNext()) { final Path file = filesIterator.next(); if (!Files.isDirectory(file)) { result.add(file); } } } catch (final IOException ex) { throw new RuntimeException("Failed to read content of input directory", ex); } Collections.sort( result, new Comparator<Path>() { @Override public int compare(final Path o1, final Path o2) { return o1.getFileName().toString().compareTo(o2.getFileName().toString()); } }); return result; }
public void testPlatformBinPermissions() throws Exception { assumeTrue("posix filesystem", isPosix); Tuple<Path, Environment> env = createEnv(fs, temp); Path pluginDir = createPluginDir(temp); Path platformDir = pluginDir.resolve("platform"); Path platformNameDir = platformDir.resolve("linux-x86_64"); Path platformBinDir = platformNameDir.resolve("bin"); Files.createDirectories(platformBinDir); Path programFile = Files.createFile(platformBinDir.resolve("someprogram")); // a file created with Files.createFile() should not have execute permissions Set<PosixFilePermission> sourcePerms = Files.getPosixFilePermissions(programFile); assertFalse(sourcePerms.contains(PosixFilePermission.OWNER_EXECUTE)); assertFalse(sourcePerms.contains(PosixFilePermission.GROUP_EXECUTE)); assertFalse(sourcePerms.contains(PosixFilePermission.OTHERS_EXECUTE)); String pluginZip = createPlugin("fake", pluginDir); installPlugin(pluginZip, env.v1()); assertPlugin("fake", pluginDir, env.v2()); // check that the installed program has execute permissions, even though the one added to the // plugin didn't Path installedPlatformBinDir = env.v2() .pluginsFile() .resolve("fake") .resolve("platform") .resolve("linux-x86_64") .resolve("bin"); assertTrue(Files.isDirectory(installedPlatformBinDir)); Path installedProgramFile = installedPlatformBinDir.resolve("someprogram"); assertTrue(Files.isRegularFile(installedProgramFile)); Set<PosixFilePermission> installedPerms = Files.getPosixFilePermissions(installedProgramFile); assertTrue(installedPerms.contains(PosixFilePermission.OWNER_EXECUTE)); assertTrue(installedPerms.contains(PosixFilePermission.GROUP_EXECUTE)); assertTrue(installedPerms.contains(PosixFilePermission.OTHERS_EXECUTE)); }
@Test public void testFileResources() throws Exception { String someResource = "/org/node/resource.txt"; File file = new File("files/node-1.0-SNAPSHOT.jar"); URL url1 = file.getAbsoluteFile().toURI().toURL(); URL url2 = new File("files/invoke-1.0-SNAPSHOT.jar").getAbsoluteFile().toURI().toURL(); URLClassLoader loader = new URLClassLoader(new URL[] {url1, url2}); final List<String> resourcePaths = Classpaths.listFromClassLoader(loader, someResource); int fileCount = 0; int dirCount = 0; for (String path : resourcePaths) { if (!Files.isDirectory(IO.path(path))) { fileCount++; } else { dirCount++; } } boolean ok = true; ok |= dirCount == 0 || die(); // ok |= fileCount == 2 || die(); }
/** Process all events for keys queued to the watcher */ void processEvents() { while (true) { // wait for key to be signalled WatchKey key; try { key = watcher.take(); } catch (InterruptedException x) { return; } Path dir = keys.get(key); if (dir == null) { System.err.println("WatchKey not recognized!!"); continue; } List<WatchEvent<?>> events = key.pollEvents(); for (WatchEvent<?> event : events) { Kind<?> kind = event.kind(); // TBD - provide example of how OVERFLOW event is handled if (kind == OVERFLOW) { continue; } // Context for directory entry event is the file name of entry WatchEvent<Path> ev = cast(event); Path name = ev.context(); Path child = dir.resolve(name); // print out event onEvent.accept(ev, child); // if directory is created, and watching recursively, then // register it and its sub-directories if (recursive && (kind == ENTRY_CREATE)) { try { if (Files.isDirectory(child, NOFOLLOW_LINKS)) { registerAll(child); } } catch (IOException x) { // ignore to keep sample readbale } } } // reset key and remove from set if directory no longer accessible boolean valid = key.reset(); if (!valid) { keys.remove(key); // all directories are inaccessible if (keys.isEmpty()) { break; } } } }
static boolean unpackZipTo(Path zipfile, Path destDirectory) throws IOException { boolean ret = true; byte[] bytebuffer = new byte[BUFFERSIZE]; ZipInputStream zipinputstream = new ZipInputStream(new FileInputStream(zipfile.toFile())); ZipEntry zipentry; while ((zipentry = zipinputstream.getNextEntry()) != null) { Path newFile = destDirectory.resolve(zipentry.getName()); if (!Files.exists(newFile.getParent(), LinkOption.NOFOLLOW_LINKS)) { Files.createDirectories(newFile.getParent()); } if (!Files.isDirectory(newFile, LinkOption.NOFOLLOW_LINKS)) { FileOutputStream fileoutputstream = new FileOutputStream(newFile.toFile()); int bytes; while ((bytes = zipinputstream.read(bytebuffer)) > -1) { fileoutputstream.write(bytebuffer, 0, bytes); } fileoutputstream.close(); } zipinputstream.closeEntry(); } zipinputstream.close(); return ret; }
/** * キー情報から実ファイルデータを取得し、それらからメタデータを生成して返します. * * @param key ファイルデータのキー情報 * @return キーから生成したメタデータ */ @Override public UrlTreeMetaData<InputStream> generateMetaDataFromReal(String key, UrlTreeContext ctx) throws BadContentException { if (!this.canLoad(key, ctx)) { throw new IllegalArgumentException( "Cannot Load it. check before can it load with canLoad(key): " + key); } Path p = this.generateFileObj(key); File f = p.toFile(); long lastModified = f.lastModified(); logger.trace("[デバッグ]ファイル名とファイルのlastModified: " + p.toString() + ":" + lastModified); UrlTreeMetaData<InputStream> md = new UrlTreeMetaData<>(); md.setDirectory(Files.isDirectory(p, LinkOption.NOFOLLOW_LINKS)); md.setFilename(key); md.setOwnerId(ctx.getUserName()); md.setGroupId(ctx.getPrimaryGroup()); md.setCreatedTime(lastModified); md.setUpdatedTime(lastModified); md.setPermission(ctx.getDefaultPermission()); String contentType = new MimetypesFileTypeMap().getContentType(p.getFileName().toString()); md.setContentType(contentType); return md; }
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; }
/** * Try to locate tools dir or tools zip * * @return path to tolls dir or tools zip * @throws FileNotFoundException if tools dir or zip not found */ private Path findToolsDir() throws FileNotFoundException { for (String location : TOOLS_SEARCH_LOCATIONS) { Path path; // search tools dir path = Paths.get(location, TOOLS_DIR_NAME); logger.info("looking for " + path); if (Files.isDirectory(path)) { logger.info("tools directory " + path + " found"); return path; } // search tools zip else { path = Paths.get(location, TOOLS_ZIP_NAME); logger.info("looking for " + path); if (Files.exists(path)) { logger.info("tools zip " + path + " found"); return path; } } } logger.warn("tools not found"); throw new FileNotFoundException("tools not found"); }
public Plugin(Settings settings) { String priorPath = settings.get(PRIOR_PATH_KEY); enabled = settings.getAsBoolean(PRIOR_STORE_ENABLED_KEY, true) && null != priorPath && Files.isDirectory(Paths.get(priorPath)); }
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); }
private static Set<ShardId> findAllShardsForIndex(Path indexPath) throws IOException { Set<ShardId> shardIds = new HashSet<>(); if (Files.isDirectory(indexPath)) { try (DirectoryStream<Path> stream = Files.newDirectoryStream(indexPath)) { String currentIndex = indexPath.getFileName().toString(); for (Path shardPath : stream) { String fileName = shardPath.getFileName().toString(); if (Files.isDirectory(shardPath) && fileName.chars().allMatch(Character::isDigit)) { int shardId = Integer.parseInt(fileName); ShardId id = new ShardId(currentIndex, shardId); shardIds.add(id); } } } } return shardIds; }