Java Path.WINDOWS属性代码示例

/**
 *  The last arg is expected to be a local path, if only one argument is
 *  given then the destination will be the current directory 
 *  @param args is the list of arguments
 */
protected void getLocalDestination(LinkedList<String> args)
throws IOException {
  String pathString = (args.size() < 2) ? Path.CUR_DIR : args.removeLast();
  try {
    dst = new PathData(new URI(pathString), getConf());
  } catch (URISyntaxException e) {
    if (Path.WINDOWS) {
      // Unlike URI, PathData knows how to parse Windows drive-letter paths.
      dst = new PathData(pathString, getConf());
    } else {
      throw new IOException("unexpected URISyntaxException", e);
    }
  }
}
 

private static void checkStat(File f, String owner, String group, 
    String expectedOwner, 
    String expectedGroup) throws IOException {
  boolean success = true;
  if (expectedOwner != null &&
      !expectedOwner.equals(owner)) {
    if (Path.WINDOWS) {
      UserGroupInformation ugi =
          UserGroupInformation.createRemoteUser(expectedOwner);
      final String adminsGroupString = "Administrators";
      success = owner.equals(adminsGroupString)
          && Arrays.asList(ugi.getGroupNames()).contains(adminsGroupString);
    } else {
      success = false;
    }
  }
  if (!success) {
    throw new IOException(
        "Owner '" + owner + "' for path " + f + " did not match " +
            "expected owner '" + expectedOwner + "'");
  }
}
 

@Override
protected List<PathData> expandArgument(String arg) throws IOException {
  List<PathData> items = new LinkedList<PathData>();
  if (arg.equals("-")) {
    readStdin = true;
  } else {
    try {
      items.add(new PathData(new URI(arg), getConf()));
    } catch (URISyntaxException e) {
      if (Path.WINDOWS) {
        // Unlike URI, PathData knows how to parse Windows drive-letter paths.
        items.add(new PathData(arg, getConf()));
      } else {
        throw new IOException("Unexpected URISyntaxException: " + e.toString());
      }
    }
  }
  return items;
}
 

@Test (timeout = 5000)
public void testInvalidWindowsPath() throws Exception {
  if (!Path.WINDOWS) {
    return;
  }

  // Verify that the following invalid paths are rejected.
  String [] winPaths = {
      "N:\\foo/bar"
  };

  for (String path : winPaths) {
    try {
      PathData item = new PathData(path, conf);
      fail("Did not throw for invalid path " + path);
    } catch (IOException ioe) {
    }
  }
}
 

/**
 * Test that opens and closes a file 10000 times - this would crash with
 * "Too many open files" if we leaked fds using this access pattern.
 */
@Test (timeout = 30000)
public void testFDDoesntLeak() throws IOException {
  if (Path.WINDOWS) {
    return;
  }

  for (int i = 0; i < 10000; i++) {
    FileDescriptor fd = NativeIO.POSIX.open(
      new File(TEST_DIR, "testNoFdLeak").getAbsolutePath(),
      NativeIO.POSIX.O_WRONLY | NativeIO.POSIX.O_CREAT, 0700);
    assertNotNull(true);
    assertTrue(fd.valid());
    FileOutputStream fos = new FileOutputStream(fd);
    fos.write("foo".getBytes());
    fos.close();
  }
}
 

@Test (timeout = 30000)
public void testOpenMissingWithoutCreate() throws Exception {
  if (Path.WINDOWS) {
    return;
  }

  LOG.info("Open a missing file without O_CREAT and it should fail");
  try {
    FileDescriptor fd = NativeIO.POSIX.open(
      new File(TEST_DIR, "doesntexist").getAbsolutePath(), O_WRONLY, 0700);
    fail("Able to open a new file without O_CREAT");
  } catch (NativeIOException nioe) {
    LOG.info("Got expected exception", nioe);
    assertEquals(Errno.ENOENT, nioe.getErrno());
  }
}
 

/**
 * Test basic chmod operation
 */
@Test (timeout = 30000)
public void testChmod() throws Exception {
  if (Path.WINDOWS) {
    return;
  }

  try {
    NativeIO.POSIX.chmod("/this/file/doesnt/exist", 777);
    fail("Chmod of non-existent file didn't fail");
  } catch (NativeIOException nioe) {
    assertEquals(Errno.ENOENT, nioe.getErrno());
  }

  File toChmod = new File(TEST_DIR, "testChmod");
  assertTrue("Create test subject",
             toChmod.exists() || toChmod.mkdir());
  NativeIO.POSIX.chmod(toChmod.getAbsolutePath(), 0777);
  assertPermissions(toChmod, 0777);
  NativeIO.POSIX.chmod(toChmod.getAbsolutePath(), 0000);
  assertPermissions(toChmod, 0000);
  NativeIO.POSIX.chmod(toChmod.getAbsolutePath(), 0644);
  assertPermissions(toChmod, 0644);
}
 

@Override
protected void testSetPermission() throws Exception {
  if (Path.WINDOWS) {
    FileSystem fs = FileSystem.get(getProxiedFSConf());
    Path path = new Path(getProxiedFSTestDir(), "foodir");
    fs.mkdirs(path);

    fs = getHttpFSFileSystem();
    FsPermission permission1 = new FsPermission(FsAction.READ_WRITE, FsAction.NONE, FsAction.NONE);
    fs.setPermission(path, permission1);
    fs.close();

    fs = FileSystem.get(getProxiedFSConf());
    FileStatus status1 = fs.getFileStatus(path);
    fs.close();
    FsPermission permission2 = status1.getPermission();
    Assert.assertEquals(permission2, permission1);

    // sticky bit not supported on Windows with local file system, so the
    // subclass skips that part of the test
  } else {
    super.testSetPermission();
  }
}
 

@Test (timeout = 30000)
public void testGetGroupName() throws IOException {
  if (Path.WINDOWS) {
    return;
  }

  assertFalse(NativeIO.POSIX.getGroupName(0).isEmpty());
}
 

@Test (timeout = 5000)
public void testToFileRawWindowsPaths() throws Exception {
  if (!Path.WINDOWS) {
    return;
  }

  // Can we handle raw Windows paths? The files need not exist for
  // these tests to succeed.
  String[] winPaths = {
      "n:\\",
      "N:\\",
      "N:\\foo",
      "N:\\foo\\bar",
      "N:/",
      "N:/foo",
      "N:/foo/bar"
  };

  PathData item;

  for (String path : winPaths) {
    item = new PathData(path, conf);
    assertEquals(new File(path), item.toFile());
  }

  item = new PathData("foo\\bar", conf);
  assertEquals(new File(testDir + "\\foo\\bar"), item.toFile());
}
 

@Test (timeout = 30000)
public void testOpenWithCreate() throws Exception {
  if (Path.WINDOWS) {
    return;
  }

  LOG.info("Test creating a file with O_CREAT");
  FileDescriptor fd = NativeIO.POSIX.open(
    new File(TEST_DIR, "testWorkingOpen").getAbsolutePath(),
    NativeIO.POSIX.O_WRONLY | NativeIO.POSIX.O_CREAT, 0700);
  assertNotNull(true);
  assertTrue(fd.valid());
  FileOutputStream fos = new FileOutputStream(fd);
  fos.write("foo".getBytes());
  fos.close();

  assertFalse(fd.valid());

  LOG.info("Test exclusive create");
  try {
    fd = NativeIO.POSIX.open(
      new File(TEST_DIR, "testWorkingOpen").getAbsolutePath(),
      NativeIO.POSIX.O_WRONLY | NativeIO.POSIX.O_CREAT | NativeIO.POSIX.O_EXCL, 0700);
    fail("Was able to create existing file with O_EXCL");
  } catch (NativeIOException nioe) {
    LOG.info("Got expected exception for failed exclusive create", nioe);
    assertEquals(Errno.EEXIST, nioe.getErrno());
  }
}
 

@Test (timeout = 30000)
public void testGetUserName() throws IOException {
  if (Path.WINDOWS) {
    return;
  }

  assertFalse(NativeIO.POSIX.getUserName(0).isEmpty());
}
 

@Test (timeout = 30000)
public void testSetFilePointer() throws Exception {
  if (!Path.WINDOWS) {
    return;
  }

  LOG.info("Set a file pointer on Windows");
  try {
    File testfile = new File(TEST_DIR, "testSetFilePointer");
    assertTrue("Create test subject",
        testfile.exists() || testfile.createNewFile());
    FileWriter writer = new FileWriter(testfile);
    try {
      for (int i = 0; i < 200; i++)
        if (i < 100)
          writer.write('a');
        else
          writer.write('b');
      writer.flush();
    } catch (Exception writerException) {
      fail("Got unexpected exception: " + writerException.getMessage());
    } finally {
      writer.close();
    }

    FileDescriptor fd = NativeIO.Windows.createFile(
        testfile.getCanonicalPath(),
        NativeIO.Windows.GENERIC_READ,
        NativeIO.Windows.FILE_SHARE_READ |
        NativeIO.Windows.FILE_SHARE_WRITE |
        NativeIO.Windows.FILE_SHARE_DELETE,
        NativeIO.Windows.OPEN_EXISTING);
    NativeIO.Windows.setFilePointer(fd, 120, NativeIO.Windows.FILE_BEGIN);
    FileReader reader = new FileReader(fd);
    try {
      int c = reader.read();
      assertTrue("Unexpected character: " + c, c == 'b');
    } catch (Exception readerException) {
      fail("Got unexpected exception: " + readerException.getMessage());
    } finally {
      reader.close();
    }
  } catch (Exception e) {
    fail("Got unexpected exception: " + e.getMessage());
  }
}
 

/**
 * Attempts to acquire an exclusive lock on the storage.
 * 
 * @return A lock object representing the newly-acquired lock or
 * <code>null</code> if storage is already locked.
 * @throws IOException if locking fails.
 */
@SuppressWarnings("resource")
FileLock tryLock() throws IOException {
  boolean deletionHookAdded = false;
  File lockF = new File(root, STORAGE_FILE_LOCK);
  if (!lockF.exists()) {
    lockF.deleteOnExit();
    deletionHookAdded = true;
  }
  RandomAccessFile file = new RandomAccessFile(lockF, "rws");
  String jvmName = ManagementFactory.getRuntimeMXBean().getName();
  FileLock res = null;
  try {
    res = file.getChannel().tryLock();
    if (null == res) {
      throw new OverlappingFileLockException();
    }
    file.write(jvmName.getBytes(Charsets.UTF_8));
    LOG.info("Lock on " + lockF + " acquired by nodename " + jvmName);
  } catch(OverlappingFileLockException oe) {
    // Cannot read from the locked file on Windows.
    String lockingJvmName = Path.WINDOWS ? "" : (" " + file.readLine());
    LOG.error("It appears that another node " + lockingJvmName
        + " has already locked the storage directory: " + root, oe);
    file.close();
    return null;
  } catch(IOException e) {
    LOG.error("Failed to acquire lock on " + lockF
        + ". If this storage directory is mounted via NFS, " 
        + "ensure that the appropriate nfs lock services are running.", e);
    file.close();
    throw e;
  }
  if (!deletionHookAdded) {
    // If the file existed prior to our startup, we didn't
    // call deleteOnExit above. But since we successfully locked
    // the dir, we can take care of cleaning it up.
    lockF.deleteOnExit();
  }
  return res;
}