public Client[] getPath(List<Path> paths) { List<Path> newPath = new LinkedList<Path>(); for (Path path : paths) { newPath.add(path); } List<Client> clientsOnPath = new LinkedList<Client>(); clientsOnPath.add(clients[0]); clientsOnPath.add(newPath.get(0).getStart()); clientsOnPath.add(newPath.get(0).getEnd()); newPath.remove(0); for (Path path : newPath) { Client start = path.getStart(); Client end = path.getEnd(); if (!clientsOnPath.contains(start)) { clientsOnPath.add(start); } if (!clientsOnPath.contains(end)) { clientsOnPath.add(end); } } clientsOnPath.add(clients[0]); Client[] result = new Client[clientsOnPath.size()]; for (int i = 0; i < clientsOnPath.size(); i++) { result[i] = clientsOnPath.get(i); } return result; }
public void initialize(InputSplit genericSplit, TaskAttemptContext context) throws IOException { FileSplit split = (FileSplit) genericSplit; Configuration job = context.getConfiguration(); m_Sb.setLength(0); m_Start = split.getStart(); m_End = m_Start + split.getLength(); final Path file = split.getPath(); compressionCodecs = new CompressionCodecFactory(job); final CompressionCodec codec = compressionCodecs.getCodec(file); // open the file and seek to the m_Start of the split FileSystem fs = file.getFileSystem(job); // getFileStatus fileStatus = fs.getFileStatus(split.getPath()); //noinspection deprecation @SuppressWarnings(value = "deprecated") long length = fs.getLength(file); FSDataInputStream fileIn = fs.open(split.getPath()); if (m_Start > 0) fileIn.seek(m_Start); if (codec != null) { CompressionInputStream inputStream = codec.createInputStream(fileIn); m_Input = new BufferedReader(new InputStreamReader(inputStream)); m_End = length; } else { m_Input = new BufferedReader(new InputStreamReader(fileIn)); } m_Current = m_Start; m_Key = split.getPath().getName(); }
/** Check that a cancelled key will never be queued */ static void testCancel(Path dir) throws IOException { System.out.println("-- Cancel --"); try (WatchService watcher = FileSystems.getDefault().newWatchService()) { System.out.format("register %s for events\n", dir); WatchKey myKey = dir.register(watcher, new WatchEvent.Kind<?>[] {ENTRY_CREATE}); checkKey(myKey, dir); System.out.println("cancel key"); myKey.cancel(); // create a file in the directory Path file = dir.resolve("mars"); System.out.format("create: %s\n", file); Files.createFile(file); // poll for keys - there will be none System.out.println("poll..."); try { WatchKey key = watcher.poll(3000, TimeUnit.MILLISECONDS); if (key != null) throw new RuntimeException("key should not be queued"); } catch (InterruptedException x) { throw new RuntimeException(x); } // done Files.delete(file); System.out.println("OKAY"); } }
public int run(String[] args) throws Exception { Configuration conf = getConf(); conf.setLong("mapreduce.task.timeout", 10000 * 60 * 60); Path train_file = new Path(args[0]); Path test_file = new Path(args[1]); conf.set("train_file", train_file.getParent().getName()); Job job = new Job(conf, "MapTestID"); job.setJarByClass(MapTestID.class); job.setOutputKeyClass(Text.class); job.setOutputValueClass(Text.class); job.setMapperClass(MapTestID.MapTestIDMap.class); job.setReducerClass(MapTestID.MapTestIDReduce.class); job.setNumReduceTasks(300); FileInputFormat.addInputPath(job, train_file); FileInputFormat.addInputPath(job, test_file); FileOutputFormat.setOutputPath(job, new Path(args[2])); return job.waitForCompletion(true) ? 0 : 1; }
private void directory_to_directory( String source_base_name, String destination_base_name, String directory_name) throws IOException, InterruptedException { // E.g. // source_base_name: /foo/bar // destination_base_name: /x/y // directory_name: abc // // - Create /x/y/abc // - Copy /foo/bar/abc/* to /x/y/abc/* // Get source directory. String source_directory_name = Path.concatenate(source_base_name, directory_name); File source_directory = File.create(source_directory_name); Assertion.check(source_directory.isDirectory()); // Get destination directory, creating it if // necessary. String destination_directory_name = Path.concatenate(destination_base_name, directory_name); File destination_directory = File.create(destination_directory_name); destination_directory.mkdirs(); // Get files in source directory String[] source_file_names = source_directory.list(); Vector source_files = new Vector(); for (int i = 0; i < source_file_names.length; i++) source_files.addElement(File.create(source_directory_name, source_file_names[i])); // Copy to_directory(source_files, destination_directory); }
private void setPathIDForRoads(List<Path> paths) { for (Path path : paths) { for (Road road : path) { roadHelper.setPathId(road.getID(), path.getId()); } } }
@Override public final Expr optimize(final QueryContext qc, final VarScope scp) throws QueryException { final Value v = initial(qc); if (v != null && v.isEmpty() || emptyPath(v)) return optPre(qc); // merge descendant steps Expr e = mergeSteps(qc); if (e == this && v != null && v.type == NodeType.DOC) { // check index access e = index(qc, v); // rewrite descendant to child steps if (e == this) e = children(qc, v); } // recompile path if it has changed if (e != this) return e.compile(qc, scp); // set atomic type for single attribute steps to speed up predicate tests if (root == null && steps.length == 1 && steps[0] instanceof Step) { final Step curr = (Step) steps[0]; if (curr.axis == ATTR && curr.test.kind == Kind.URI_NAME) curr.seqType(SeqType.NOD_ZO); } // choose best path implementation and set type information final Path path = get(info, root, steps); path.size = path.size(qc); path.seqType = SeqType.get(steps[steps.length - 1].seqType().type, size); return path; }
/** * Initializes default class loader. It inherits from classloader, which was used to load this * task, therefore build-in classes and resources are loaded automatically. * * <p>Notice: task's classpath has priority over default classpath, therefore we are able to * easily override resources (templates) */ protected void initClassloader() { // NOTICE: we should use the same classloader, which was used to load this task // otherwise we won't be able to cast instances // (that were loaded via different class loaders) // we are introducting workaround, // that tries to add classpath for current task to original class loader // and stores original classpath // after the task is executed, classpath is restored ClassLoader classLoader = getClass().getClassLoader(); if (classLoader instanceof AntClassLoader) { // add defined classpath AntClassLoader antClassLoader = (AntClassLoader) classLoader; antClassLoader.setParentFirst(false); antClassLoader.setProject(getProject()); savedClasspath = antClassLoader.getClasspath(); Path cp = getClasspath(); // add defined classpath to original path cp.add(new Path(getProject(), savedClasspath)); antClassLoader.setClassPath(cp); } else { // create new class loader classLoader = new AntClassLoader(getClass().getClassLoader(), getProject(), getClasspath(), false); } // set this class loader as new class loader for whole thread // ContextClassLoader is used in StringTemplate's PathGroupLoader and other classes Thread.currentThread().setContextClassLoader(classLoader); }
public static void main(String[] args) throws Exception { Path dir1 = TestUtil.createTemporaryDirectory(); try { // Same directory testCopyFileToFile(dir1, dir1, TestUtil.supportsLinks(dir1)); testMove(dir1, dir1, TestUtil.supportsLinks(dir1)); // Different directories. Use test.dir if possible as it might be // a different volume/file system and so improve test coverage. String testDir = System.getProperty("test.dir", "."); Path dir2 = TestUtil.createTemporaryDirectory(testDir); try { boolean testSymbolicLinks = TestUtil.supportsLinks(dir1) && TestUtil.supportsLinks(dir2); testCopyFileToFile(dir1, dir2, testSymbolicLinks); testMove(dir1, dir2, testSymbolicLinks); } finally { TestUtil.removeAll(dir2); } // Target is location associated with custom provider Path dir3 = PassThroughFileSystem.create().getPath(dir1.toString()); testCopyFileToFile(dir1, dir3, false); testMove(dir1, dir3, false); // Test copy(InputStream,Path) and copy(Path,OutputStream) testCopyInputStreamToFile(); testCopyFileToOuputStream(); } finally { TestUtil.removeAll(dir1); } }
/** * Recursively rebuild the tree nodes. * * @param root The full abstract path to the root saved layout directory. * @param local The current directory relative to root (null if none). * @param tnode The current parent tree node. */ private void rebuildTreeModel(Path root, Path local, DefaultMutableTreeNode tnode) { TreeSet<Path> subdirs = new TreeSet<Path>(); TreeSet<String> layouts = new TreeSet<String>(); { Path current = new Path(root, local); File files[] = current.toFile().listFiles(); if (files != null) { int wk; for (wk = 0; wk < files.length; wk++) { String name = files[wk].getName(); if (files[wk].isDirectory()) subdirs.add(new Path(local, name)); else if (files[wk].isFile()) layouts.add(name); } } } for (Path subdir : subdirs) { TreeData data = new TreeData(subdir); DefaultMutableTreeNode child = new DefaultMutableTreeNode(data, true); tnode.add(child); rebuildTreeModel(root, subdir, child); } for (String lname : layouts) { TreeData data = new TreeData(new Path(local, lname), lname); DefaultMutableTreeNode child = new DefaultMutableTreeNode(data, false); tnode.add(child); } }
private static List<LinkedHashMap<String, Object>> getFeaturesForClass( GraphDatabaseService db, Node classNode) { List<LinkedHashMap<String, Object>> patternIds = new ArrayList<>(); for (Path p : db.traversalDescription() .depthFirst() .relationships(withName("HAS_CLASS"), Direction.INCOMING) .evaluator(Evaluators.fromDepth(1)) .evaluator(Evaluators.toDepth(1)) .traverse(classNode)) { LinkedHashMap<String, Object> featureMap = new LinkedHashMap<>(); if (p.relationships().iterator().hasNext()) { featureMap.put("frequency", p.relationships().iterator().next().getProperty("matches")); } else { featureMap.put("frequency", 0); } featureMap.put("feature", ((Long) p.endNode().getId()).intValue()); patternIds.add(featureMap); } return patternIds; }
private static IntWritable deduceInputFile(JobConf job) { Path[] inputPaths = FileInputFormat.getInputPaths(job); Path inputFile = new Path(job.get("map.input.file")); // value == one for sort-input; value == two for sort-output return (inputFile.getParent().equals(inputPaths[0])) ? sortInput : sortOutput; }
public static FileDesc loadFile(Path root, Path file, int blocSize) throws NoSuchAlgorithmException, FileNotFoundException, IOException { MessageDigest md = MessageDigest.getInstance("SHA-512"); MessageDigest fileMd = MessageDigest.getInstance("SHA-512"); FileDesc desc = new FileDesc(file.toString(), null, null); List<Bloc> list = new ArrayList<Bloc>(); try (FileInputStream fis = new FileInputStream(root.resolve(file).toString())) { byte[] buf = new byte[blocSize]; byte[] h; int s; while ((s = fis.read(buf)) != -1) { int c; while (s < buf.length && (c = fis.read()) != -1) buf[s++] = (byte) c; fileMd.update(buf, 0, s); // padding byte p = 0; while (s < buf.length) buf[s++] = ++p; h = md.digest(buf); Bloc bloc = new Bloc(RollingChecksum.compute(buf), new Hash(h)); list.add(bloc); } h = fileMd.digest(); desc.fileHash = new Hash(h); desc.blocs = list.toArray(new Bloc[0]); } return desc; }
/** check a candidate plugin for jar hell before installing it */ private void jarHellCheck(Path candidate, boolean isolated) throws IOException { // create list of current jars in classpath final List<URL> jars = new ArrayList<>(Arrays.asList(JarHell.parseClassPath())); // read existing bundles. this does some checks on the installation too. List<Bundle> bundles = PluginsService.getPluginBundles(environment.pluginsFile()); // if we aren't isolated, we need to jarhellcheck against any other non-isolated plugins // thats always the first bundle if (isolated == false) { jars.addAll(bundles.get(0).urls); } // add plugin jars to the list Path pluginJars[] = FileSystemUtils.files(candidate, "*.jar"); for (Path jar : pluginJars) { jars.add(jar.toUri().toURL()); } // check combined (current classpath + new jars to-be-added) try { JarHell.checkJarHell(jars.toArray(new URL[jars.size()])); } catch (Exception ex) { throw new RuntimeException(ex); } }
private static boolean exists(Path p) { Path base = p.getParent(); String fileName = p.getFileName().toString(); return Arrays.asList(extensions) .stream() .anyMatch(it -> Files.exists(base.resolve(fileName + it))); }
private String copyFromLocal(FileSystem fs, Path basePath, String[] files) throws IOException { StringBuilder csv = new StringBuilder(files.length * (basePath.toString().length() + 16)); for (String localFile : files) { Path src = new Path(localFile); String filename = src.getName(); Path dst = new Path(basePath, filename); URI localFileURI = null; try { localFileURI = new URI(localFile); } catch (URISyntaxException e) { throw new IOException(e); } if (localFileURI.getScheme() == null || localFileURI.getScheme().startsWith("file")) { LOG.info("Copy {} from local filesystem to {}", localFile, dst); fs.copyFromLocalFile(false, true, src, dst); } else { LOG.info("Copy {} from DFS to {}", localFile, dst); FileUtil.copy(fs, src, fs, dst, false, true, conf); } if (csv.length() > 0) { csv.append(LIB_JARS_SEP); } csv.append(dst.toString()); } return csv.toString(); }
private void uploadFile(String relPath, Path fullPath) throws DropboxException, IOException { if (!fullPath.toFile().exists()) return; /*if(api.metadata(relPath, 1, null, false, null).rev == MetaHandler.getRev(relPath)){ logger.debug("File "+relPath+" not changed"); return; }*/ VOSync.debug("Uploading " + relPath); String rev = MetaHandler.getRev(relPath); InputStream inp = new FileInputStream(fullPath.toFile()); Entry fileEntry = api.putFile(relPath, inp, fullPath.toFile().length(), rev, null); inp.close(); Path destFilePath = FileSystems.getDefault() .getPath(fullPath.toFile().getParentFile().getPath(), fileEntry.fileName()); MetaHandler.setFile(relPath, destFilePath.toFile(), fileEntry.rev); logger.debug(relPath + " put to db"); // if the file was renamed, move the file on disk and download the current from server if (!fileEntry.fileName().equals(fullPath.toFile().getName())) { logger.error(fileEntry.fileName() + " != " + fullPath.toFile().getName()); fullPath.toFile().renameTo(destFilePath.toFile()); } }
public void registerPath(String path) { boolean contentAlreadyRegistered = false; File hudsonFile = JenkinsFilesHelper.buildFileFromPathRelativeToHudsonRoot(path); Path pathToRegister = new Path(hudsonFile); if (pathToRegister.isDirectory()) { pathContents.put(pathToRegister, new byte[0]); } else { // Verifying if path content is already in pathContent and, if this is the case, // look at checksums if (pathContents.containsKey(pathToRegister)) { try { contentAlreadyRegistered = Checksums.fileAndByteArrayContentAreEqual( pathToRegister.getHudsonFile(), pathContents.get(pathToRegister)); } catch (IOException e) { throw new LoggableException( "Changeset path <" + path + "> registration failed", Checksums.class, "fileAndByteArrayContentAreEqual", e); } } if (!contentAlreadyRegistered) { try { pathContents.put(pathToRegister, Files.toByteArray(pathToRegister.getHudsonFile())); } catch (IOException e) { throw new LoggableException( "Changeset path <" + path + "> registration failed", Files.class, "toByteArray", e); } } } }
private Path getNearestPath(Road road, List<Path> paths) { int range = 10000; int minDistance = Integer.MAX_VALUE; EntityID nearestPath = null; while (nearestPath == null) { Collection<StandardEntity> entities = world.getObjectsInRange(road, range); for (StandardEntity entity : entities) { if (entity instanceof Road) { EntityID pathId = roadHelper.getPathId(entity.getID()); if (pathId != null) { int distance = Util.distance((Area) entity, road); if (distance < minDistance) { nearestPath = pathId; minDistance = distance; } } } } range += 10000; } for (Path path : paths) { if (path.getId().equals(nearestPath)) { return path; } } return null; }
private static void finalize( Configuration conf, JobConf jobconf, final Path destPath, String presevedAttributes) throws IOException { if (presevedAttributes == null) { return; } EnumSet<FileAttribute> preseved = FileAttribute.parse(presevedAttributes); if (!preseved.contains(FileAttribute.USER) && !preseved.contains(FileAttribute.GROUP) && !preseved.contains(FileAttribute.PERMISSION)) { return; } FileSystem dstfs = destPath.getFileSystem(conf); Path dstdirlist = new Path(jobconf.get(DST_DIR_LIST_LABEL)); SequenceFile.Reader in = null; try { in = new SequenceFile.Reader(dstdirlist.getFileSystem(jobconf), dstdirlist, jobconf); Text dsttext = new Text(); FilePair pair = new FilePair(); for (; in.next(dsttext, pair); ) { Path absdst = new Path(destPath, pair.output); updatePermissions(pair.input, dstfs.getFileStatus(absdst), preseved, dstfs); } } finally { checkAndClose(in); } }
public void onDraw(Canvas canvas) { // 검정색 배경으로 지운다. 빈 화면이면 지우기만 하고 리턴 canvas.drawColor(Color.BLACK); if (status == BLANK) { return; } // 도형 목록을 순회하면서 도형 정보대로 출력한다. int idx; for (idx = 0; idx < arShape.size(); idx++) { Paint Pnt = new Paint(); Pnt.setAntiAlias(true); Pnt.setColor(arShape.get(idx).color); Rect rt = arShape.get(idx).rt; switch (arShape.get(idx).what) { case Shape.RECT: canvas.drawRect(rt, Pnt); break; case Shape.CIRCLE: canvas.drawCircle( rt.left + rt.width() / 2, rt.top + rt.height() / 2, rt.width() / 2, Pnt); break; case Shape.TRIANGLE: Path path = new Path(); path.moveTo(rt.left + rt.width() / 2, rt.top); path.lineTo(rt.left, rt.bottom); path.lineTo(rt.right, rt.bottom); canvas.drawPath(path, Pnt); break; } } }
/** {@inheritDoc} */ protected void doRenderGraphic(DrawContext dc) { for (Path path : this.paths) { path.render(dc); } this.arrowHead1.render(dc); this.arrowHead2.render(dc); }
private void addToPath(Road road, EntityID pathId, List<Path> paths) { for (Path path : paths) { if (path.getId().equals(pathId)) { adding(road, path); break; } } }
protected Path createPath() { Path path = new Path(); path.setFollowTerrain(true); path.setPathType(AVKey.GREAT_CIRCLE); path.setAltitudeMode(WorldWind.CLAMP_TO_GROUND); path.setDelegateOwner(this.getActiveDelegateOwner()); return path; }
// copy source to target with verification static void copyAndVerify(Path source, Path target, CopyOption... options) throws IOException { Path result = copy(source, target, options); assertTrue(result == target); // get attributes of source and target file to verify copy boolean followLinks = true; LinkOption[] linkOptions = new LinkOption[0]; boolean copyAttributes = false; for (CopyOption opt : options) { if (opt == NOFOLLOW_LINKS) { followLinks = false; linkOptions = new LinkOption[] {NOFOLLOW_LINKS}; } if (opt == COPY_ATTRIBUTES) copyAttributes = true; } BasicFileAttributes basicAttributes = readAttributes(source, BasicFileAttributes.class, linkOptions); // check hash if regular file if (basicAttributes.isRegularFile()) assertTrue(computeHash(source) == computeHash(target)); // check link target if symbolic link if (basicAttributes.isSymbolicLink()) assert (readSymbolicLink(source).equals(readSymbolicLink(target))); // check that attributes are copied if (copyAttributes && followLinks) { checkBasicAttributes( basicAttributes, readAttributes(source, BasicFileAttributes.class, linkOptions)); // verify other attributes when same provider if (source.getFileSystem().provider() == target.getFileSystem().provider()) { // check POSIX attributes are copied String os = System.getProperty("os.name"); if ((os.equals("SunOS") || os.equals("Linux")) && testPosixAttributes) { checkPosixAttributes( readAttributes(source, PosixFileAttributes.class, linkOptions), readAttributes(target, PosixFileAttributes.class, linkOptions)); } // check DOS attributes are copied if (os.startsWith("Windows")) { checkDosAttributes( readAttributes(source, DosFileAttributes.class, linkOptions), readAttributes(target, DosFileAttributes.class, linkOptions)); } // check named attributes are copied if (followLinks && getFileStore(source).supportsFileAttributeView("xattr") && getFileStore(target).supportsFileAttributeView("xattr")) { checkUserDefinedFileAttributes( readUserDefinedFileAttributes(source), readUserDefinedFileAttributes(target)); } } } }
/** Returns the {@code NodePath.path} for this shard. */ public static Path shardStatePathToDataPath(Path shardPath) { int count = shardPath.getNameCount(); // Sanity check: assert Integer.parseInt(shardPath.getName(count - 1).toString()) >= 0; assert "indices".equals(shardPath.getName(count - 3).toString()); return shardPath.getParent().getParent().getParent(); }
private void adding(Road road, Path path) { roadHelper.setPathId(road.getID(), path.getId()); if (!path.contains(road)) { path.add(road); if (entrances.contains(road)) { path.addEntrance(getEntrance(road)); } } }
private ArrayList<Path> holeLaufwerkeWindows() { ArrayList<Path> laufwerksRoot = new ArrayList<>(); Iterable<Path> rootDirectories = FileSystems.getDefault().getRootDirectories(); for (Path path : rootDirectories) { laufwerksRoot.add(path.getRoot()); } return laufwerksRoot; }
public static String absolutePath(Path p) { if (p == null) return ""; StringBuilder sb = new StringBuilder(); Path parentPath = p.getParent(); if (parentPath == null) return "/"; sb.append(absolutePath(parentPath)); if (sb.length() > 1) sb.append("/"); sb.append(p.getName()); return sb.toString(); }
@Override public FileVisitResult preVisitDirectory(Path dir, BasicFileAttributes attrs) throws IOException { Path targetPath = toPath.resolve(fromPath.relativize(dir)); if (!Files.exists(targetPath)) { targetPath.toFile().mkdirs(); // Files.createDirectory(targetPath); } return FileVisitResult.CONTINUE; }