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

/**
 * Ensures configured directory {@code path} exists.
 * @throws IOException if {@code path} exists, but is not a directory, not accessible, or broken symbolic link.
 */
static void ensureDirectoryExists(Path path) throws IOException {
    // this isn't atomic, but neither is createDirectories.
    if (Files.isDirectory(path)) {
        // verify access, following links (throws exception if something is wrong)
        // we only check READ as a sanity test
        path.getFileSystem().provider().checkAccess(path.toRealPath(), AccessMode.READ);
    } else {
        // doesn't exist, or not a directory
        try {
            Files.createDirectories(path);
        } catch (FileAlreadyExistsException e) {
            // convert optional specific exception so the context is clear
            IOException e2 = new NotDirectoryException(path.toString());
            e2.addSuppressed(e);
            throw e2;
        }
    }
}

/**
 * Starts this Muxer, if not already started.
 *
 * This is thread safe to be called at any time, multiple times. Returns immediately.
 *
 * @throws IOException
 */
public void start()
        throws IOException {
    if (state.compareAndSet(NOT_STARTED, RUNNING)) {
        try {
            access(mkv, AccessMode.READ);
            access(srt, AccessMode.READ);
            access(tempDir, AccessMode.WRITE);
            output.toFile().deleteOnExit();
            ProcessBuilder builder = factory.from("mkvmerge", "-o", output.toString(), mkv.toString(), srt.toString());
            builder.directory(tempDir.toFile()).inheritIO(); // TODO: Better solution than inheritIO
            process = builder.start();
        } catch (Exception e) {
            state.set(FAILED);
            deleteWarn(output);
            throw e;
        }
    }
}

/**
 * Ensures configured directory {@code path} exists.
 * @throws IOException if {@code path} exists, but is not a directory, not accessible, or broken symbolic link.
 */
static void ensureDirectoryExists(Path path) throws IOException {
    // this isn't atomic, but neither is createDirectories.
    if (Files.isDirectory(path)) {
        // verify access, following links (throws exception if something is wrong)
        // we only check READ as a sanity test
        path.getFileSystem().provider().checkAccess(path.toRealPath(), AccessMode.READ);
    } else {
        // doesn't exist, or not a directory
        try {
            Files.createDirectories(path);
        } catch (FileAlreadyExistsException e) {
            // convert optional specific exception so the context is clear
            IOException e2 = new NotDirectoryException(path.toString());
            e2.addSuppressed(e);
            throw e2;
        }
    }
}

@Override
public void checkAccess(Path path, AccessMode... modes) throws IOException {
    CloudPath cloudPath = getCloudPath(path);
    CloudFileSystemImplementation sourceCloudFileSystemImplementation = getCloudFileSystemImplementation(cloudPath);

    // Work out permissions to check
    Set<AclEntryPermission> checkPermissions = EnumSet.noneOf(AclEntryPermission.class);
    Arrays.stream(modes).forEach(m ->
            {
                if (AccessMode.EXECUTE.equals(m)) {
                    checkPermissions.add(AclEntryPermission.EXECUTE);
                } else if (AccessMode.READ.equals(m)) {
                    checkPermissions.add(AclEntryPermission.READ_DATA);
                } else if (AccessMode.WRITE.equals(m)) {
                    checkPermissions.add(AclEntryPermission.WRITE_DATA);
                }
            });

    sourceCloudFileSystemImplementation.checkAccess(getBlobStoreContext(cloudPath), cloudPath, checkPermissions);
}

public AbstractLocalFileSystem( URI uri, FileSystemProvider provider, Path cachePath, Map<String, Object> env,
                                BiFunction<Path, Map<String, ?>, FileSystemIO> fileSystemIO )
        throws IOException
{
    super( uri, provider, env, cachePath, fileSystemIO );

    this.cachePath = getFileSystemIO().getBaseDirectory();

    if( Files.notExists( cachePath ) ) {
        Files.createDirectories( cachePath );
    }

    // sm and existence check
    cachePath.getFileSystem().provider().checkAccess( cachePath, AccessMode.READ );
    if( !Files.isWritable( cachePath ) ) {
        setReadOnly( true );
    }
}

@Override
public void checkAccess(Path path, AccessMode... modes) throws IOException
{
  JPath jPath = (JPath) path;
  Status status;

  try {
    status = jPath.getBfsFile().getStatus();
  }
  catch (Exception e) {
    throw createIOException(e);
  }

  if (status.getType() == Status.FileType.FILE) {
    // do nothing
  }
  else if (status.getType() == Status.FileType.DIRECTORY) {
    // do nothing
  }
  else {
    throw new NoSuchFileException(path.toUri().toString());
  }
}

/** {@inheritDoc} */
@Override
public void move(Path source, Path target, CopyOption... options) throws IOException {

    source = ((TestPath) source).unwrap();
    target = ((TestPath) target).unwrap();

    checkIfRemoved(source);

    Path sourceParent = source.getParent();
    if (sourceParent != null) {
        checkIfRemoved(sourceParent);
        checkPermissions(sourceParent, true, AccessMode.WRITE);
    }

    Path targetParent = target.getParent();
    if (targetParent != null) {
        checkIfRemoved(targetParent);
        checkPermissions(targetParent, true, AccessMode.WRITE);
    }

    provider.move(source, target, options);
}

protected AbstractTarFileSystem(AbstractTarFileSystemProvider provider,
        Path tfpath, Map<String, ?> env) throws IOException {
    // configurable env setup
    createNew = "true".equals(env.get("create"));
    defaultDir = env.containsKey("default.dir") ? (String) env
            .get("default.dir") : "/";
    entriesToData = new HashMap<>();
    if (defaultDir.charAt(0) != '/') {
        throw new IllegalArgumentException("default dir should be absolute");
    }
    this.provider = provider;
    this.tfpath = tfpath;
    if (Files.notExists(tfpath)) {
        if (!createNew) {
            throw new FileSystemNotFoundException(tfpath.toString());
        }
    }
    // sm and existence check
    tfpath.getFileSystem().provider().checkAccess(tfpath, AccessMode.READ);
    if (!Files.isWritable(tfpath)) {
        readOnly = true;
    }
    defaultdir = new TarPath(this, defaultDir.getBytes());
    outputStreams = new ArrayList<>();
    mapEntries();
}

public Set<AccessMode> accessModeMaskToSet(int mask) {
    Set<AccessMode> accessModes = EnumSet.noneOf(AccessMode.class);
    // @formatter:off
    if ((mask & AccessConstants.R_OK) == AccessConstants.R_OK) accessModes.add(AccessMode.READ);
    if ((mask & AccessConstants.W_OK) == AccessConstants.W_OK) accessModes.add(AccessMode.WRITE);
    if ((mask & AccessConstants.X_OK) == AccessConstants.X_OK) accessModes.add(AccessMode.EXECUTE);
    // @formatter:on
    return accessModes;
}

@Override
public int access(String path, int mask) {
    try {
        Path node = resolvePath(path);
        Set<AccessMode> accessModes = attrUtil.accessModeMaskToSet(mask);
        return checkAccess(node, accessModes);
    } catch (RuntimeException e) {
        LOG.error("checkAccess failed.", e);
        return -ErrorCodes.EIO();
    }
}

@ParameterizedTest
@MethodSource("accessModeProvider")
public void testAccessModeMaskToSet(Set<AccessMode> expectedModes, int mask) {
    FileAttributesUtil util = new FileAttributesUtil();
    Set<AccessMode> accessModes = util.accessModeMaskToSet(mask);
    Assertions.assertEquals(expectedModes, accessModes);
}

static Stream<Arguments> accessModeProvider() {
    return Stream.of( //
            Arguments.of(EnumSet.noneOf(AccessMode.class), 0), //
            Arguments.of(EnumSet.of(AccessMode.READ), AccessConstants.R_OK), //
            Arguments.of(EnumSet.of(AccessMode.WRITE), AccessConstants.W_OK), //
            Arguments.of(EnumSet.of(AccessMode.EXECUTE), AccessConstants.X_OK), //
            Arguments.of(EnumSet.of(AccessMode.READ, AccessMode.WRITE), AccessConstants.R_OK | AccessConstants.W_OK), //
            Arguments.of(EnumSet.allOf(AccessMode.class), AccessConstants.R_OK | AccessConstants.W_OK | AccessConstants.X_OK | AccessConstants.F_OK) //
    );
}

/**
 * Add access to a directory iff it exists already
 * @param policy current policy to add permissions to
 * @param configurationName the configuration name associated with the path (for error messages only)
 * @param path the path itself
 * @param permissions set of file permissions to grant to the path
 */
static void addPathIfExists(Permissions policy, String configurationName, Path path, String permissions) {
    if (Files.isDirectory(path)) {
        // add each path twice: once for itself, again for files underneath it
        policy.add(new FilePermission(path.toString(), permissions));
        policy.add(new FilePermission(path.toString() + path.getFileSystem().getSeparator() + "-", permissions));
        try {
            path.getFileSystem().provider().checkAccess(path.toRealPath(), AccessMode.READ);
        } catch (IOException e) {
            throw new IllegalStateException("Unable to access '" + configurationName + "' (" + path + ")", e);
        }
    }
}

private FileNode begin() throws IOException {
    final FileNode buffer;
    final Path entryFile = node.getPath();
    Boolean exists = null;
    if (options.get(EXCLUSIVE) && (exists = exists(entryFile)))
        throw new FileAlreadyExistsException(node.toString());
    if (options.get(CACHE)) {
        // This is obviously NOT properly isolated.
        if (TRUE.equals(exists)
                || null == exists && (exists = exists(entryFile))) {
            //if (!isWritable(entryFile)) throw new IOException(...)
            entryFile   .getFileSystem()
                        .provider()
                        .checkAccess(entryFile, AccessMode.WRITE);
        } else {
            createFile(entryFile);
        }
        buffer = node.createIoBuffer();
    } else {
        buffer = node;
    }
    if (options.get(CREATE_PARENTS) && !TRUE.equals(exists)) {
        final Path parentFile = entryFile.getParent();
        if (null != parentFile) {
            try {
                createDirectories(parentFile);
            } catch (IOException ex) {
                // Workaround for bug in Oracle JDK 1.7.0_51:
                // A call to Files.createDirectories("C:\\") will fail on
                // Windows although it shouldn't.
                // Likewise, a call to Files.createDirectories("/") will
                // fail on Mac OS X although it shouldn't.
                // On Linux, it supposedly works however.
                if (!isDirectory(parentFile)) throw ex;
            }
        }
    }
    return buffer;
}

@Test
public void testMkvMustBeReadable()
        throws Exception {
    doThrow(new NoSuchFileException(null)).when(provider).checkAccess(mkv, AccessMode.READ);
    exception.expect(NoSuchFileException.class);
    muxer.start();
}

@Test
public void testSrtMustBeReadable()
        throws Exception {
    doThrow(new NoSuchFileException(null)).when(provider).checkAccess(srt, AccessMode.READ);
    exception.expect(NoSuchFileException.class);
    muxer.start();
}

@Test
public void testempDirMustBeWriteable()
        throws Exception {
    doThrow(new NoSuchFileException(null)).when(provider).checkAccess(tempDir, AccessMode.WRITE);
    exception.expect(NoSuchFileException.class);
    muxer.start();
}

@Test
public void testIOExceptionInStartGoesToFailedState()
        throws Exception {
    // Given
    doThrow(new NoSuchFileException(null)).when(provider).checkAccess(tempDir, AccessMode.WRITE);
    Muxer muxer = Muxer.of(mkv, srt, tempDir);
    try {
        muxer.start();
        fail("Must throw NoSuchFileException");
    } catch (NoSuchFileException e) { // NOPMD: Ignored
    }
    // Then
    assertThat(muxer.state()).isEqualTo(State.FAILED);
}

@Override
public void checkAccess(Path file, AccessMode... modes)
    throws IOException
{
    triggerEx(file, "checkAccess");
    // hack
    if (modes.length == 0) {
        if (Files.exists(unwrap(file)))
            return;
        else
            throw new NoSuchFileException(file.toString());
    }
    throw new RuntimeException("not implemented yet");
}

@Override
public void checkAccess(Path file, AccessMode... modes)
    throws IOException
{
    triggerEx(file, "checkAccess");
    // hack
    if (modes.length == 0) {
        if (Files.exists(unwrap(file)))
            return;
        else
            throw new NoSuchFileException(file.toString());
    }
    throw new RuntimeException("not implemented yet");
}

@Override
public void checkAccess(Path file, AccessMode... modes)
    throws IOException
{
    triggerEx(file, "checkAccess");
    // hack
    if (modes.length == 0) {
        if (Files.exists(unwrap(file)))
            return;
        else
            throw new NoSuchFileException(file.toString());
    }
    throw new RuntimeException("not implemented yet");
}

@Override
public void checkAccess(Path path, AccessMode... modes) throws IOException {
    MCRPath mcrPath = MCRFileSystemUtils.checkPathAbsolute(path);
    MCRFilesystemNode node = resolvePath(mcrPath);
    if (node == null) {
        throw new NoSuchFileException(mcrPath.toString());
    }
    if (node instanceof MCRDirectory) {
        checkDirectory((MCRDirectory) node, modes);
    } else {
        checkFile((MCRFile) node, modes);
    }
}

private void checkDirectory(MCRDirectory rootDirectory, AccessMode... modes) throws AccessDeniedException {
    for (AccessMode mode : modes) {
        switch (mode) {
            case READ:
            case WRITE:
            case EXECUTE:
                break;
            default:
                throw new UnsupportedOperationException("Unsupported AccessMode: " + mode);
        }
    }
}

private void checkFile(MCRFile file, AccessMode... modes) throws AccessDeniedException {
    for (AccessMode mode : modes) {
        switch (mode) {
            case READ:
            case WRITE:
                break;
            case EXECUTE:
                throw new AccessDeniedException(file.toPath().toString(), null, "Unsupported AccessMode: " + mode);
            default:
                throw new UnsupportedOperationException("Unsupported AccessMode: " + mode);
        }
    }
}

@Override
public void checkAccess(Path path, AccessMode... modes) throws IOException
{
  BootJar jar = jar(path);

  if (jar == null) {
    throw new FileNotFoundException(L.l("{0} does not exist", path));
  }
}

@Override
public void checkAccess(Path path, AccessMode... modes) throws IOException
{
  URL url = getURL(path);

  if (url == null) {
    throw new IOException(L.l("{0} does not exist", path));
  }
}

@Override
public void checkAccess(Path file, AccessMode... modes)
    throws IOException
{
    triggerEx(file, "checkAccess");
    // hack
    if (modes.length == 0) {
        if (Files.exists(unwrap(file)))
            return;
        else
            throw new NoSuchFileException(file.toString());
    }
    throw new RuntimeException("not implemented yet");
}

@Override
public void checkAccess(Path file, AccessMode... modes)
    throws IOException
{
    triggerEx(file, "checkAccess");
    // hack
    if (modes.length == 0) {
        if (Files.exists(unwrap(file)))
            return;
        else
            throw new NoSuchFileException(file.toString());
    }
    throw new RuntimeException("not implemented yet");
}

@Override
public void checkAccess(Path file, AccessMode... modes) throws IOException {
    if (modes.length == 0) {
        if (Files.exists(EncryptedFileSystem.dismantle(file)))
            return;
        else
            throw new NoSuchFileException(file.toString());
    }

    // see
    // https://docs.oracle.com/javase/7/docs/api/java/nio/file/spi/FileSystemProvider.html#checkAccess%28java.nio.file.Path,%20java.nio.file.AccessMode...%29
    throw new UnsupportedOperationException("not implemented");
}

/**
 * Creates a new instance.
 *
 * @param fs the wrapped file system
 * @param removedPaths paths that don't exist in this file system provider
 * @param addedPathTargets targets for additional paths that only exist in this file system provider
 * @param addedPathPermissions permissions for additional paths that only exist in this file system provider
 * @param exceptionPaths access to these files using these access modes should trigger an {@link IOException}
 */
TestFileSystemProvider(FileSystem fs, List< String > removedPaths, Map< String, String > addedPathTargets,
                Map< String, Permissions > addedPathPermissions, Map< String, Set< AccessMode > > exceptionPaths) {

    this.provider = fs.provider();

    this.removedPaths = new ArrayList< Path >();
    for (String removedPath : removedPaths) {
        this.removedPaths.add(fs.getPath(removedPath).toAbsolutePath());
    }

    this.addedPathTargets = new HashMap<>();
    for (Map.Entry< String, String > addedPath : addedPathTargets.entrySet()) {
        this.addedPathTargets.put(fs.getPath(addedPath.getKey()).toAbsolutePath(), fs.getPath(addedPath.getValue())
                        .toAbsolutePath());
    }

    this.addedPathPermissions = new HashMap<>();
    for (Map.Entry< String, Permissions > addedPathPermission : addedPathPermissions.entrySet()) {
        this.addedPathPermissions.put(fs.getPath(addedPathPermission.getKey()).toAbsolutePath(),
                        addedPathPermission.getValue());
    }

    this.exceptionPaths = new HashMap<>();
    for (Map.Entry< String, Set< AccessMode > > entry : exceptionPaths.entrySet()) {
        this.exceptionPaths.put(fs.getPath(entry.getKey()).toAbsolutePath(), entry.getValue());
    }
}

private static AccessMode[] toAccessModes(Set< ? extends OpenOption > options) {

        boolean write = options.contains(StandardOpenOption.WRITE);
        boolean append = options.contains(StandardOpenOption.APPEND);

        List< AccessMode > modes = new ArrayList<>();
        if (write || append) {
            modes.add(AccessMode.WRITE);
        } else {
            modes.add(AccessMode.READ);
        }

        return modes.toArray(new AccessMode[modes.size()]);
    }

/** {@inheritDoc} */
@Override
public DirectoryStream< Path > newDirectoryStream(Path dir, Filter< ? super Path > filter) throws IOException {

    dir = ((TestPath) dir).unwrap();

    checkIfRemoved(dir);
    checkPermissions(dir, true, AccessMode.READ);

    return provider.newDirectoryStream(dir, filter);
}

/** {@inheritDoc} */
@Override
public void createDirectory(Path dir, FileAttribute< ? >... attrs) throws IOException {

    dir = ((TestPath) dir).unwrap();

    Path parent = dir.getParent();
    if (parent != null) {
        checkIfRemoved(parent);
        checkPermissions(parent, true, AccessMode.WRITE);
    }

    provider.createDirectory(dir, attrs);
}

/** {@inheritDoc} */
@Override
public void delete(Path path) throws IOException {

    path = ((TestPath) path).unwrap();

    checkIfRemoved(path);

    Path parent = path.getParent();
    if (parent != null) {
        checkPermissions(parent, true, AccessMode.WRITE);
    }

    provider.delete(path);
}

/** {@inheritDoc} */
@Override
public void copy(Path source, Path target, CopyOption... options) throws IOException {

    source = ((TestPath) source).unwrap();
    target = ((TestPath) target).unwrap();

    checkIfRemoved(source);
    checkPermissions(source, true, AccessMode.READ);

    provider.copy(source, target, options);
}

/** {@inheritDoc} */
@Override
public void checkAccess(Path path, AccessMode... modes) throws IOException {

    path = ((TestPath) path).unwrap();

    checkIfRemoved(path);

    boolean checked = checkPermissions(path, false, modes);
    if (!checked) {
        provider.checkAccess(path, modes);
    }
}

private boolean checkPermissions(Path path, boolean checkExceptions, AccessMode... modes)
                throws AccessDeniedException, IOException {
    Permissions permissions = addedPathPermissions.get(path.toAbsolutePath());
    boolean hasPermissions = permissions != null;
    if (hasPermissions) {
        for (AccessMode mode : modes) {
            switch (mode) {
                case READ:
                    if (permissions != RWX && permissions != R_X && permissions != RW_ && permissions != R__) {
                        throw new AccessDeniedException(path.toString());
                    }
                    break;
                case WRITE:
                    if (permissions != RWX && permissions != _WX && permissions != RW_ && permissions != _W_) {
                        throw new AccessDeniedException(path.toString());
                    }
                    break;
                case EXECUTE:
                    if (permissions != RWX && permissions != _WX && permissions != R_X && permissions != __X) {
                        throw new AccessDeniedException(path.toString());
                    }
                    break;
                default:
                    // impossible
            }
        }
    }
    if (checkExceptions) {
        checkExceptions(path, modes);
    }
    return hasPermissions;
}

private void checkExceptions(Path path, AccessMode... modes) throws IOException {
    Set< AccessMode > errorModes = exceptionPaths.get(path.toAbsolutePath());
    if (errorModes != null) {
        for (AccessMode mode : modes) {
            if (errorModes.contains(mode)) {
                throw new IOException(path.toString());
            }
        }
    }
}

/**
 * Simulates an {@link IOException} whenever the specified files are read from or written to.
 *
 * @param paths the paths of the files which are to trigger an {@link IOException} on read or write
 * @param mode the access mode that should trigger the {@link IOException} (read or write)
 * @return this test file system builder, ready for further customization
 */
private TestFS throwingException(String[] paths, AccessMode mode) {
    for (String path : paths) {
        Set< AccessMode > modes = exceptionPaths.get(path);
        if (modes == null) {
            modes = new HashSet<>(3);
            exceptionPaths.put(path, modes);
        }
        modes.add(mode);
    }
    return this;
}

@Override
public void checkAccess(Path file, AccessMode... modes)
    throws IOException
{
    triggerEx(file, "checkAccess");
    // hack
    if (modes.length == 0) {
        if (Files.exists(unwrap(file)))
            return;
        else
            throw new NoSuchFileException(file.toString());
    }
    throw new RuntimeException("not implemented yet");
}