Java 类java.nio.file.InvalidPathException 实例源码

/**
 * Make a temporary copy of a JAR file.
 */
static File makeTempJar(File moduleFile) throws IOException {
    String prefix = moduleFile.getName();
    if (prefix.endsWith(".jar") || prefix.endsWith(".JAR")) { // NOI18N
        prefix = prefix.substring(0, prefix.length() - 4);
    }
    if (prefix.length() < 3) prefix += '.';
    if (prefix.length() < 3) prefix += '.';
    if (prefix.length() < 3) prefix += '.';
    String suffix = "-test.jar"; // NOI18N
    File physicalModuleFile = File.createTempFile(prefix, suffix);
    physicalModuleFile.deleteOnExit();
    try (InputStream is = Files.newInputStream(moduleFile.toPath());
            OutputStream os = Files.newOutputStream(physicalModuleFile.toPath())) {
        byte[] buf = new byte[4096];
        int i;
        while ((i = is.read(buf)) != -1) {
            os.write(buf, 0, i);
        }
    } catch (InvalidPathException ex) {
        throw new IOException(ex);
    }
    err.fine("Made " + physicalModuleFile);
    return physicalModuleFile;
}

private static boolean clustersChanged() {
    if (clustersChanged != null) {
        return clustersChanged;
    }

    final String clustersCache = "all-clusters.dat"; // NOI18N
    File f = fileImpl(clustersCache, null, -1); // no timestamp check
    if (f != null) {
        try (DataInputStream dis = new DataInputStream(Files.newInputStream(f.toPath()))) {
            if (Clusters.compareDirs(dis)) {
                return false;
            }
        } catch (IOException | InvalidPathException ex) {
            return clustersChanged = true;
        }
    } else {
        // missing cluster file signals caches are OK, for 
        // backward compatibility
        return clustersChanged = false;
    }
    return clustersChanged = true;
}

protected byte[] readClass(String path) throws IOException {
    File clsFile = new File(dir, path.replace('/', File.separatorChar));
    if (!clsFile.exists()) return null;

    int len = (int)clsFile.length();
    byte[] data = new byte[len];
    try (InputStream is = Files.newInputStream(clsFile.toPath())) {
        int count = 0;
        while (count < len) {
            count += is.read(data, count, len - count);
        }
        return data;
    } catch (InvalidPathException ex) {
        throw new IOException(ex);
    }
}

private static File copyJAR(FileObject fo, URI archiveFileURI, boolean replace) throws IOException {
    synchronized (copiedJARs) {
        File copy = copiedJARs.get(archiveFileURI);
        if (copy == null || replace) {
            if (copy == null) {
                copy = File.createTempFile("copy", "-" + archiveFileURI.toString().replaceFirst(".+/", "")); // NOI18N
                copy = copy.getCanonicalFile();
                copy.deleteOnExit();
            }
            try (InputStream is = fo.getInputStream(); OutputStream os = Files.newOutputStream(copy.toPath())) {
                FileUtil.copy(is, os);
            } catch (InvalidPathException ex) {
                throw new IOException(ex);
            }
            copiedJARs.put(archiveFileURI, copy);
        }
        return copy;
    }
}

protected OutputStream outputStream(final String name) throws java.io.IOException {
    File f = getFile(name);
    if (!f.exists()) {
        f.getParentFile().mkdirs();
    }
    try {
        OutputStream retVal = new BufferedOutputStream(Files.newOutputStream(f.toPath()));

        // workaround for #42624
        if (BaseUtilities.isMac()) {
            retVal = getOutputStreamForMac42624(retVal, name);
        }
        return retVal;
    } catch (InvalidPathException ex) {
        throw new IOException(ex);
    }
}

private static boolean pathToURISupported() {
    Boolean res = pathURIConsistent;
    if (res == null) {
        boolean c;
        try {
            final File f = new File("küñ"); //NOI18N
            c = f.toPath().toUri().equals(f.toURI());
        } catch (InvalidPathException e) {
            c = false;
        }
        if (!c) {
            LOG.fine("The java.nio.file.Path.toUri is inconsistent with java.io.File.toURI");   //NOI18N
        }
        res = pathURIConsistent = c;
    }
    return res;
}

private String randomNonTranslogPatternString(int min, int max) {
    String string;
    boolean validPathString;
    do {
        validPathString = false;
        string = randomRealisticUnicodeOfCodepointLength(randomIntBetween(min, max));
        try {
            final Path resolved = translogDir.resolve(string);
            // some strings (like '/' , '..') do not refer to a file, which we this method should return
            validPathString = resolved.getFileName() != null;
        } catch (InvalidPathException ex) {
            // some FS don't like our random file names -- let's just skip these random choices
        }
    } while (Translog.PARSE_STRICT_ID_PATTERN.matcher(string).matches() || validPathString == false);
    return string;
}

private static Path createPathFromText(String text) {
    if (text == null || text.isEmpty()) return null;
    if (text.startsWith("\"") && text.endsWith("\"")) text = text.substring(1, text.length() - 1);
    if (!text.endsWith(DLL_NAME)) return null;

    try {
        Path path = Paths.get(text);
        if (!Files.isRegularFile(path)) {
            error("Read error", "The DLL file you selected cannot be found.");
            return null;
        } else if (!Files.isReadable(path) || !Files.isWritable(path)) {
            error("Read error", "The DLL file you selected cannot be read from or written to.\n\n" +
                    "Make sure that the file is not marked read-only and\n" +
                    "that you have the required permissions to write to it.");
            return null;
        }

        return path;
    } catch (InvalidPathException ipe) {
        return null;
    }
}

public static Path parseRelativePath(Node node, Path def) throws InvalidXMLException {
    if(node == null) return def;
    final String text = node.getValueNormalize();
    try {
        Path path = Paths.get(text);
        if(path.isAbsolute()) {
            throw new InvalidPathException(text, "Path is not relative");
        }
        for(Path part : path) {
            if(part.toString().trim().startsWith("..")) {
                throw new InvalidPathException(text, "Path contains an invalid component");
            }
        }
        return path;
    } catch(InvalidPathException e) {
        throw new InvalidXMLException("Invalid relative path '" + text + "'", node, e);
    }
}

/**
 * @param name Absolute path
 */
public Local(final String name) throws LocalAccessDeniedException {
    String path = name;
    if(PreferencesFactory.get().getBoolean("local.normalize.unicode")) {
        path = new NFCNormalizer().normalize(path).toString();
    }
    if(PreferencesFactory.get().getBoolean("local.normalize.tilde")) {
        path = new TildeExpander().expand(path);
    }
    if(PreferencesFactory.get().getBoolean("local.normalize.prefix")) {
        path = new WorkdirPrefixer().normalize(path);
    }
    try {
        this.path = Paths.get(path).toString();
    }
    catch(InvalidPathException e) {
        throw new LocalAccessDeniedException(String.format("The name %s is not a valid path for the filesystem", path), e);
    }
    this.attributes = new LocalAttributes(path);
}

public static ProxyClassesDumper getInstance(String path) {
    if (null == path) {
        return null;
    }
    try {
        path = path.trim();
        final Path dir = Paths.get(path.length() == 0 ? "." : path);
        AccessController.doPrivileged(new PrivilegedAction<Void>() {
                @Override
                public Void run() {
                    validateDumpDir(dir);
                    return null;
                }
            }, null, new FilePermission("<<ALL FILES>>", "read, write"));
        return new ProxyClassesDumper(dir);
    } catch (InvalidPathException ex) {
        PlatformLogger.getLogger(ProxyClassesDumper.class.getName())
                      .warning("Path " + path + " is not valid - dumping disabled", ex);
    } catch (IllegalArgumentException iae) {
        PlatformLogger.getLogger(ProxyClassesDumper.class.getName())
                      .warning(iae.getMessage() + " - dumping disabled");
    }
    return null;
}

public void dumpClass(String className, final byte[] classBytes) {
    Path file;
    try {
        file = dumpDir.resolve(encodeForFilename(className) + ".class");
    } catch (InvalidPathException ex) {
        PlatformLogger.getLogger(ProxyClassesDumper.class.getName())
                      .warning("Invalid path for class " + className);
        return;
    }

    try {
        Path dir = file.getParent();
        Files.createDirectories(dir);
        Files.write(file, classBytes);
    } catch (Exception ignore) {
        PlatformLogger.getLogger(ProxyClassesDumper.class.getName())
                      .warning("Exception writing to path at " + file.toString());
        // simply don't care if this operation failed
    }
}

public static ProxyClassesDumper getInstance(String path) {
    if (null == path) {
        return null;
    }
    try {
        path = path.trim();
        final Path dir = Paths.get(path.length() == 0 ? "." : path);
        AccessController.doPrivileged(new PrivilegedAction<Void>() {
                @Override
                public Void run() {
                    validateDumpDir(dir);
                    return null;
                }
            }, null, new FilePermission("<<ALL FILES>>", "read, write"));
        return new ProxyClassesDumper(dir);
    } catch (InvalidPathException ex) {
        PlatformLogger.getLogger(ProxyClassesDumper.class.getName())
                      .warning("Path " + path + " is not valid - dumping disabled", ex);
    } catch (IllegalArgumentException iae) {
        PlatformLogger.getLogger(ProxyClassesDumper.class.getName())
                      .warning(iae.getMessage() + " - dumping disabled");
    }
    return null;
}

public void dumpClass(String className, final byte[] classBytes) {
    Path file;
    try {
        file = dumpDir.resolve(encodeForFilename(className) + ".class");
    } catch (InvalidPathException ex) {
        PlatformLogger.getLogger(ProxyClassesDumper.class.getName())
                      .warning("Invalid path for class " + className);
        return;
    }

    try {
        Path dir = file.getParent();
        Files.createDirectories(dir);
        Files.write(file, classBytes);
    } catch (Exception ignore) {
        PlatformLogger.getLogger(ProxyClassesDumper.class.getName())
                      .warning("Exception writing to path at " + file.toString());
        // simply don't care if this operation failed
    }
}

@Override
    public final List<Plugin> loadPlugins(String pluginFolder, boolean autoregister) {
        File folder = new File(pluginFolder);
        LOGGER.debug("Loading from supplied plugin folder");
        if (!folder.isDirectory()) {
            throw new InvalidPathException(pluginFolder, "Set a valid plugin directory");
        } else {
            List<Plugin> loaded;
//            if (isDebug()) {
//                loaded = loadDebug(folder);
//            } else {
            loaded = load(folder);
//            }
            if (autoregister) {
                for (Plugin p : loaded) {
                    getContext().addPlugin(p);
                }
                return loaded;
            } else {
                return loaded;
            }
        }
    }

@Override
public boolean isValid(final String value, final ConstraintValidatorContext context) {
    try {
        if (StringUtils.isEmpty(value)) {
            return true; // do not validate empty value there are other constraints for that e.g. @NotNull, @Size etc...
        }

        final Path path = Paths.get(value);

        if (checkIfExists && !path.toFile().exists()) {
            return false;
        }

        final String fileExt = FilenameUtils.getExtension(value);
        return allowableFileExtensions.isEmpty() ||
               !allowableFileExtensions.stream().filter(fileExt::equalsIgnoreCase).findFirst().orElse(StringUtils.EMPTY).isEmpty();

    } catch (final InvalidPathException e) {
        LOGGER.error(e.getMessage(), e);
        return false;
    }
}

public static ProxyClassesDumper getInstance(String path) {
    if (null == path) {
        return null;
    }
    try {
        path = path.trim();
        final Path dir = Paths.get(path.length() == 0 ? "." : path);
        AccessController.doPrivileged(new PrivilegedAction<>() {
                @Override
                public Void run() {
                    validateDumpDir(dir);
                    return null;
                }
            }, null, new FilePermission("<<ALL FILES>>", "read, write"));
        return new ProxyClassesDumper(dir);
    } catch (InvalidPathException ex) {
        PlatformLogger.getLogger(ProxyClassesDumper.class.getName())
                      .warning("Path " + path + " is not valid - dumping disabled", ex);
    } catch (IllegalArgumentException iae) {
        PlatformLogger.getLogger(ProxyClassesDumper.class.getName())
                      .warning(iae.getMessage() + " - dumping disabled");
    }
    return null;
}

public void dumpClass(String className, final byte[] classBytes) {
    Path file;
    try {
        file = dumpDir.resolve(encodeForFilename(className) + ".class");
    } catch (InvalidPathException ex) {
        PlatformLogger.getLogger(ProxyClassesDumper.class.getName())
                      .warning("Invalid path for class " + className);
        return;
    }

    try {
        Path dir = file.getParent();
        Files.createDirectories(dir);
        Files.write(file, classBytes);
    } catch (Exception ignore) {
        PlatformLogger.getLogger(ProxyClassesDumper.class.getName())
                      .warning("Exception writing to path at " + file.toString());
        // simply don't care if this operation failed
    }
}

public static ProxyClassesDumper getInstance(String path) {
    if (null == path) {
        return null;
    }
    try {
        path = path.trim();
        final Path dir = Paths.get(path.length() == 0 ? "." : path);
        AccessController.doPrivileged(new PrivilegedAction<>() {
                @Override
                public Void run() {
                    validateDumpDir(dir);
                    return null;
                }
            }, null, new FilePermission("<<ALL FILES>>", "read, write"));
        return new ProxyClassesDumper(dir);
    } catch (InvalidPathException ex) {
        PlatformLogger.getLogger(ProxyClassesDumper.class.getName())
                      .warning("Path " + path + " is not valid - dumping disabled", ex);
    } catch (IllegalArgumentException iae) {
        PlatformLogger.getLogger(ProxyClassesDumper.class.getName())
                      .warning(iae.getMessage() + " - dumping disabled");
    }
    return null;
}

public void dumpClass(String className, final byte[] classBytes) {
    Path file;
    try {
        file = dumpDir.resolve(encodeForFilename(className) + ".class");
    } catch (InvalidPathException ex) {
        PlatformLogger.getLogger(ProxyClassesDumper.class.getName())
                      .warning("Invalid path for class " + className);
        return;
    }

    try {
        Path dir = file.getParent();
        Files.createDirectories(dir);
        Files.write(file, classBytes);
    } catch (Exception ignore) {
        PlatformLogger.getLogger(ProxyClassesDumper.class.getName())
                      .warning("Exception writing to path at " + file.toString());
        // simply don't care if this operation failed
    }
}

public static ProxyClassesDumper getInstance(String path) {
    if (null == path) {
        return null;
    }
    try {
        path = path.trim();
        final Path dir = Paths.get(path.length() == 0 ? "." : path);
        AccessController.doPrivileged(new PrivilegedAction<Void>() {
                @Override
                public Void run() {
                    validateDumpDir(dir);
                    return null;
                }
            }, null, new FilePermission("<<ALL FILES>>", "read, write"));
        return new ProxyClassesDumper(dir);
    } catch (InvalidPathException ex) {
        PlatformLogger.getLogger(ProxyClassesDumper.class.getName())
                      .warning("Path " + path + " is not valid - dumping disabled", ex);
    } catch (IllegalArgumentException iae) {
        PlatformLogger.getLogger(ProxyClassesDumper.class.getName())
                      .warning(iae.getMessage() + " - dumping disabled");
    }
    return null;
}

public void dumpClass(String className, final byte[] classBytes) {
    Path file;
    try {
        file = dumpDir.resolve(encodeForFilename(className) + ".class");
    } catch (InvalidPathException ex) {
        PlatformLogger.getLogger(ProxyClassesDumper.class.getName())
                      .warning("Invalid path for class " + className);
        return;
    }

    try {
        Path dir = file.getParent();
        Files.createDirectories(dir);
        Files.write(file, classBytes);
    } catch (Exception ignore) {
        PlatformLogger.getLogger(ProxyClassesDumper.class.getName())
                      .warning("Exception writing to path at " + file.toString());
        // simply don't care if this operation failed
    }
}

private char[] normalize( char[] path )
{
    if( path.length == 0 ) {
        return path;
    }
    char prevC = 0;
    for( int i = 0; i < path.length; i++ ) {
        char c = path[i];
        if( c == '\\' ) {
            return normalize( path, i );
        }
        if( c == (char) '/' && prevC == '/' ) {
            return normalize( path, i - 1 );
        }
        if( c == '\u0000' ) {
            throw new InvalidPathException( String.valueOf( path ), "Path: nul character not allowed" );
        }
        prevC = c;
    }
    return path;
}

/**
 * Create a subpath (subdirectory or file) below a given path.
 * 
 * The provided element name is sanitized first if necessary.
 * 
 * @param path
 *            Path to create new element below
 * @param subElement
 *            Name representing single path segment (slashes will be
 *            replaced)
 * @return Resulting path with new subelement
 */
public static Path createSafeSubpath(final Path path, final String subElement) {
    // remove slashes, as subElement just represents a single segment
    String halfSafeElement = subElement.replaceAll("[\\\\/]", "_");

    // - leading dots may hide items in some systems
    // - trailing dots are ignored in windows
    //  => replace both to avoid side effects
    halfSafeElement = halfSafeElement.replaceAll("^\\.+|\\.+$", "_");

    Path subPath;
    try {
        // try without sanitizing first, because the user's FS might
        // be less restrictive
        subPath = path.resolve(halfSafeElement);
    } catch (InvalidPathException e) {
        subPath = path.resolve(PathUtil.sanitizePathElement(halfSafeElement));
    }

    return subPath;
}

/**
 * Validates that the source download location is a valid path name.
 * 
 * @param logger
 *            used to log any messages
 */
protected void validateTargetFolder(PrintStream logger)
{
    String targetFolder = getTargetFolder();
    if (StringUtils.isNotEmpty(targetFolder))
    {
        logger.println(Messages.targetFolder() + " = " + targetFolder); //$NON-NLS-1$
        try
        {
            Paths.get(targetFolder);
        }
        catch (InvalidPathException exc)
        {
            throw new IllegalArgumentException(Messages.invalidSourceDownloadLocation(exc.getLocalizedMessage()));
        }
    }
}

public static void main(String[] args) {

        FileSystem fs = FileSystems.getDefault();

        String linuxPath = "/home/ard/Documents/tmp-pdf.txt";           // this is a linux filesytem path.
        String windowsPath = "C:\\Users\\aaron.decker\\Documents";      // in java you must escape backslashes

        Path testPath = fs.getPath(linuxPath);
        System.out.println(testPath);

        Path testPath2 = fs.getPath(windowsPath, "tmp.txt");
        System.out.println(testPath2);

        try {
            // null char is not allowed on linux "\0"
            // on windows ? is not allowed.
            Path testPath3 = fs.getPath("\0");  // special NULL char.
            System.out.println(testPath3);
        } catch (InvalidPathException e ) {
            System.out.println(e);
        }

    }

@SuppressWarnings("unchecked")
@Override
public <V extends FileAttributeView> V getFileAttributeView(Path path, Class<V> type, LinkOption... options) {
    if (path != null) {
        MCRPath file = checkRelativePath(path);
        if (file.getNameCount() != 1) {
            throw new InvalidPathException(path.toString(), "'path' must have one name component.");
        }
    }
    checkClosed();
    if (type == null) {
        throw new NullPointerException();
    }
    //must support BasicFileAttributeView
    if (type == BasicFileAttributeView.class) {
        return (V) new BasicFileAttributeViewImpl(this, path);
    }
    if (type == MCRMD5AttributeView.class) {
        return (V) new MD5FileAttributeViewImpl(this, path);
    }
    return null;
}

/**
 * Gets the configured custom program {@link Path} from the
 * {@link Configuration} using the specified key. If the specified key has
 * no value, {@code null} is returned.
 *
 * @param configurationKey the {@link Configuration} key to use.
 * @return The resulting {@link Path} or {@code null}.
 * @throws ConfigurationException If the configured value can't be parsed as
 *             a valid {@link Path}.
 */
@Nullable
public Path getCustomProgramPath(@Nullable String configurationKey) throws ConfigurationException {
    if (isBlank(configurationKey) || configuration == null) {
        return null;
    }

    try {
        String configuredPath = configuration.getString(configurationKey);
        if (isBlank(configuredPath)) {
            return null;
        }
        return Paths.get(configuredPath);
    } catch (ConversionException | InvalidPathException e) {
        throw new ConfigurationException(
            "Invalid configured custom program path in \"" + configurationKey + "\": " + e.getMessage(),
            e
        );
    }
}

static LuaFunction loadTextChunkFromFile(FileSystem fileSystem, ChunkLoader loader, String fileName, ByteString modeString, Object env)
        throws LoaderException {

    final LuaFunction fn;
    try {
        Path p = fileSystem.getPath(fileName);

        if (!modeString.contains((byte) 't')) {
            throw new LuaRuntimeException("attempt to load a text chunk (mode is '" + modeString + "')");
        }

        // FIXME: this is extremely wasteful!
        byte[] bytes = Files.readAllBytes(p);
        ByteString chunkText = ByteString.copyOf(bytes);
        fn = loader.loadTextChunk(new Variable(env), fileName, chunkText.toString());
    }
    catch (InvalidPathException | IOException ex) {
        throw new LoaderException(ex, fileName);
    }

    if (fn == null) {
        throw new LuaRuntimeException("loader returned nil");
    }

    return fn;
}

@Nullable
private static Path searchPaths(List<String> possiblePaths) {
  for (String pathString : possiblePaths) {
    if (pathString != null) {
      try {
        Path path = Paths.get(pathString);
        if (Files.exists(path)) {
          return path;
        }
      } catch (InvalidPathException ex) {
        // ignore
      }
    }
  }
  return null;
}

@VisibleForTesting
Path getWindowsPythonPath() {
  String cloudSdkPython = System.getenv("CLOUDSDK_PYTHON");
  if (cloudSdkPython != null) {
    Path cloudSdkPythonPath = Paths.get(cloudSdkPython);
    if (Files.exists(cloudSdkPythonPath)) {
      return cloudSdkPythonPath;
    } else {
      throw new InvalidPathException(cloudSdkPython, "python binary not in specified location");
    }
  }

  Path pythonPath = getSdkPath().resolve(WINDOWS_BUNDLED_PYTHON);
  if (Files.exists(pythonPath)) {
    return pythonPath;
  } else {
    return Paths.get("python");
  }
}

public static BufferedImage loadImage(String path) {
    try {
        if (Files.exists(Paths.get(path))) {
            return ImageIO.read(new File(path));
        }

        InputStream local = DataHandler.class.getResourceAsStream(path);

        if (local != null) {
            return ImageIO.read(local);
        }

        return ImageIO.read(new URL(path));
    }
    catch (InvalidPathException | IOException exception) {
        return null;
    }
}

private File generateReport(IScanIssue[] issues){
    File report = null;
    try{
        String OS = System.getProperty("os.name").toUpperCase(Locale.getDefault());
        Path env;
        if (OS.contains("WIN")){
            env = Paths.get(System.getenv("APPDATA"),"Code Dx","Burp Extension");
        }
        else if (OS.contains("MAC")){
            env = Paths.get(System.getProperty("user.home"),"Library","Application Support","Code Dx","Burp Extension");
        }
        else if (OS.contains("NUX")){
            env = Paths.get(System.getProperty("user.home"),".codedx","burp-extension");
        }
        else{
            env = Paths.get(System.getProperty("user.dir"),"codedx","burp-extension");
        }
        env.toFile().mkdirs();
        report = new File(env.toFile(),"Burp.xml");
    } catch(SecurityException | InvalidPathException | UnsupportedOperationException e){}
    callbacks.generateScanReport("XML", issues, report);
    return report;
}

public static ProxyClassesDumper getInstance(String path) {
    if (null == path) {
        return null;
    }
    try {
        path = path.trim();
        final Path dir = Paths.get(path.length() == 0 ? "." : path);
        AccessController.doPrivileged(new PrivilegedAction<Void>() {
                @Override
                public Void run() {
                    validateDumpDir(dir);
                    return null;
                }
            }, null, new FilePermission("<<ALL FILES>>", "read, write"));
        return new ProxyClassesDumper(dir);
    } catch (InvalidPathException ex) {
        PlatformLogger.getLogger(ProxyClassesDumper.class.getName())
                      .warning("Path " + path + " is not valid - dumping disabled", ex);
    } catch (IllegalArgumentException iae) {
        PlatformLogger.getLogger(ProxyClassesDumper.class.getName())
                      .warning(iae.getMessage() + " - dumping disabled");
    }
    return null;
}

public void dumpClass(String className, final byte[] classBytes) {
    Path file;
    try {
        file = dumpDir.resolve(encodeForFilename(className) + ".class");
    } catch (InvalidPathException ex) {
        PlatformLogger.getLogger(ProxyClassesDumper.class.getName())
                      .warning("Invalid path for class " + className);
        return;
    }

    try {
        Path dir = file.getParent();
        Files.createDirectories(dir);
        Files.write(file, classBytes);
    } catch (Exception ignore) {
        PlatformLogger.getLogger(ProxyClassesDumper.class.getName())
                      .warning("Exception writing to path at " + file.toString());
        // simply don't care if this operation failed
    }
}

public static ProxyClassesDumper getInstance(String path) {
    if (null == path) {
        return null;
    }
    try {
        path = path.trim();
        final Path dir = Paths.get(path.length() == 0 ? "." : path);
        AccessController.doPrivileged(new PrivilegedAction<Void>() {
                @Override
                public Void run() {
                    validateDumpDir(dir);
                    return null;
                }
            }, null, new FilePermission("<<ALL FILES>>", "read, write"));
        return new ProxyClassesDumper(dir);
    } catch (InvalidPathException ex) {
        PlatformLogger.getLogger(ProxyClassesDumper.class.getName())
                      .warning("Path " + path + " is not valid - dumping disabled", ex);
    } catch (IllegalArgumentException iae) {
        PlatformLogger.getLogger(ProxyClassesDumper.class.getName())
                      .warning(iae.getMessage() + " - dumping disabled");
    }
    return null;
}

public void dumpClass(String className, final byte[] classBytes) {
    Path file;
    try {
        file = dumpDir.resolve(encodeForFilename(className) + ".class");
    } catch (InvalidPathException ex) {
        PlatformLogger.getLogger(ProxyClassesDumper.class.getName())
                      .warning("Invalid path for class " + className);
        return;
    }

    try {
        Path dir = file.getParent();
        Files.createDirectories(dir);
        Files.write(file, classBytes);
    } catch (Exception ignore) {
        PlatformLogger.getLogger(ProxyClassesDumper.class.getName())
                      .warning("Exception writing to path at " + file.toString());
        // simply don't care if this operation failed
    }
}

static String getGradlePath(String resourcePath) {
    String gradlePath = "";
    String resourceFilePath = resourcePath;
    int jarFileIndex = resourcePath.lastIndexOf(EXCLAMATION_MARK);
    if (jarFileIndex > -1) {
        resourceFilePath = resourcePath.substring(0, jarFileIndex);
    }
    if (resourceFilePath.startsWith(JAR_FILE_PREFIX)) {
        resourceFilePath = resourceFilePath.replaceAll(JAR_FILE_PREFIX, FILE_PREFIX);
    }
    if (!resourceFilePath.startsWith(FILE_PREFIX)) {
        resourceFilePath = FILE_PREFIX + resourceFilePath;
    }
    try {
        Path jarPath = Paths.get(new URI(resourceFilePath));
        gradlePath = jarPath.resolveSibling(GRADLE_FOLDER).toString();
    } catch (InvalidPathException | URISyntaxException ex) {
        LOG.log(Level.SEVERE, null, ex);
    }
    return gradlePath;
}

/**
 * Expand
 * 
 * @param pathWithPlaceholder
 * @return
 */
@Override
public IPath expand(String pathWithPlaceholder) {
    String variableName = getPlaceholderName(pathWithPlaceholder);
    if (variableName == null) {
        try {
            return new Path(pathWithPlaceholder);
        } catch (InvalidPathException e) {
            return null;
        }
    }
    String other = pathWithPlaceholder.substring(variableName.length() + 4);
    PathPlaceholder pathPlaceholder = mappings.get(variableName);
    if (pathPlaceholder == null || pathPlaceholder.getPath() == null) {
        return null;
    }
    return pathPlaceholder.getPath().append(other);
}

/**
 * Export a file to a destination
 *
 * @param file:     File to export
 * @param dest:     File object with path to destination directory
 * @param prefix:   Prefix to be added to file name
 * @return true if successful export
 * @throws IOException
 * @throws InvalidPathException
 */
public static boolean exportFile(File file, File dest, String prefix) throws IOException, InvalidPathException {
    if (!copyFile(file, dest)) { //one of the files failed to be copied
        return false;
    }

    // Resolve file name
    File resultFile = new File(dest.getAbsolutePath() + File.separator + file.getName());
    String resultName = resultFile.getName();
    String regex = MATCH_DIGIT_TO_FIRST_ALPHA;
    resultName = resultName.replaceFirst(regex, "");

    // Rename file
    String targetName = resultFile.getParent() + File.separator + prefix + "_" + resultName;
    File targetFile = new File(targetName);
    Path result = Files.move(resultFile.toPath(), targetFile.toPath(), StandardCopyOption.REPLACE_EXISTING);
    return result.toFile().equals(targetFile);
}