Java Shell.WINDOWS属性代码示例

/**
 * Create the ResourceCalculatorPlugin from the class name and configure it. If
 * class name is null, this method will try and return a memory calculator
 * plugin available for this system.
 *
 * @param clazz ResourceCalculator plugin class-name
 * @param conf configure the plugin with this.
 * @return ResourceCalculatorPlugin or null if ResourceCalculatorPlugin is not
 * 		 available for current system
 */
public static ResourceCalculatorPlugin getResourceCalculatorPlugin(
    Class<? extends ResourceCalculatorPlugin> clazz, Configuration conf) {

  if (clazz != null) {
    return ReflectionUtils.newInstance(clazz, conf);
  }

  // No class given, try a os specific class
  try {
    if (Shell.LINUX) {
      return new LinuxResourceCalculatorPlugin();
    }
    if (Shell.WINDOWS) {
      return new WindowsResourceCalculatorPlugin();
    }
  } catch (SecurityException se) {
    // Failed to get Operating System name.
    return null;
  }

  // Not supported on this system.
  return null;
}
 

/**
 * Create a FileInputStream that shares delete permission on the
 * file opened at a given offset, i.e. other process can delete
 * the file the FileInputStream is reading. Only Windows implementation
 * uses the native interface.
 */
public static FileInputStream getShareDeleteFileInputStream(File f, long seekOffset)
    throws IOException {
  if (!Shell.WINDOWS) {
    RandomAccessFile rf = new RandomAccessFile(f, "r");
    if (seekOffset > 0) {
      rf.seek(seekOffset);
    }
    return new FileInputStream(rf.getFD());
  } else {
    // Use Windows native interface to create a FileInputStream that
    // shares delete permission on the file opened, and set it to the
    // given offset.
    //
    FileDescriptor fd = NativeIO.Windows.createFile(
        f.getAbsolutePath(),
        NativeIO.Windows.GENERIC_READ,
        NativeIO.Windows.FILE_SHARE_READ |
            NativeIO.Windows.FILE_SHARE_WRITE |
            NativeIO.Windows.FILE_SHARE_DELETE,
        NativeIO.Windows.OPEN_EXISTING);
    if (seekOffset > 0)
      NativeIO.Windows.setFilePointer(fd, seekOffset, NativeIO.Windows.FILE_BEGIN);
    return new FileInputStream(fd);
  }
}
 

public static void chmod(String path, int mode) throws IOException {
	if (!Shell.WINDOWS) {
		chmodImpl(path, mode);
	} else {
		try {
			chmodImpl(path, mode);
		} catch (NativeIOException nioe) {
			if (nioe.getErrorCode() == 3) {
				throw new NativeIOException("No such file or directory", Errno.ENOENT);
			} else {
				LOG.warn(
						String.format("NativeIO.chmod error (%d): %s", nioe.getErrorCode(), nioe.getMessage()));
				throw new NativeIOException("Unknown error", Errno.UNKNOWN);
			}
		}
	}
}
 

public static boolean isAvailable() {
  if (Shell.WINDOWS) {
    ShellCommandExecutor shellExecutor = new ShellCommandExecutor(
        new String[] { Shell.WINUTILS, "help" });
    try {
      shellExecutor.execute();
    } catch (IOException e) {
      LOG.error(StringUtils.stringifyException(e));
    } finally {
      String output = shellExecutor.getOutput();
      if (output != null &&
          output.contains("Prints to stdout a list of processes in the task")) {
        return true;
      }
    }
  }
  return false;
}
 

/**
 * Create a FileInputStream that shares delete permission on the
 * file opened, i.e. other process can delete the file the
 * FileInputStream is reading. Only Windows implementation uses
 * the native interface.
 */
public static FileInputStream getShareDeleteFileInputStream(File f)
    throws IOException {
  if (!Shell.WINDOWS) {
    // On Linux the default FileInputStream shares delete permission
    // on the file opened.
    //
    return new FileInputStream(f);
  } else {
    // Use Windows native interface to create a FileInputStream that
    // shares delete permission on the file opened.
    //
    FileDescriptor fd = Windows.createFile(
        f.getAbsolutePath(),
        Windows.GENERIC_READ,
        Windows.FILE_SHARE_READ |
            Windows.FILE_SHARE_WRITE |
            Windows.FILE_SHARE_DELETE,
        Windows.OPEN_EXISTING);
    return new FileInputStream(fd);
  }
}
 

@Override
public boolean rename(Path src, Path dst) throws IOException {
  // Attempt rename using Java API.
  File srcFile = pathToFile(src);
  File dstFile = pathToFile(dst);
  if (srcFile.renameTo(dstFile)) {
    return true;
  }

  // Else try POSIX style rename on Windows only
  if (Shell.WINDOWS &&
      handleEmptyDstDirectoryOnWindows(src, srcFile, dst, dstFile)) {
    return true;
  }

  // The fallback behavior accomplishes the rename by a full copy.
  if (LOG.isDebugEnabled()) {
    LOG.debug("Falling through to a copy of " + src + " to " + dst);
  }
  return FileUtil.copy(this, src, this, dst, true, getConf());
}
 

public static String getContainerLogNetworkPath(String nodeHostName, String amLogDirs, String containerId) {
  String trimmedLogDirs = amLogDirs.substring(0, amLogDirs.lastIndexOf("/"));
  if (Shell.WINDOWS) {
    String sharedLogDirs;
    if (amLogDirs.startsWith("D:")) {
      sharedLogDirs = trimmedLogDirs.replace("D:", "drived").replace("/", "\\");
    } else {
      sharedLogDirs = "drived" + trimmedLogDirs.replace("/", "\\");
    }
    return String.format("\\\\%s\\%s\\%s", nodeHostName, sharedLogDirs, containerId);
  } else {
    return String.format("%s:%s/%s", nodeHostName, trimmedLogDirs, containerId);
  }
}
 

/**
 *  tweak some of the contract parameters based on the local system
 *  state
 */
protected void adjustContractToLocalEnvironment() {
  if (Shell.WINDOWS) {
    //NTFS doesn't do case sensitivity, and its permissions are ACL-based
    getConf().setBoolean(getConfKey(ContractOptions.IS_CASE_SENSITIVE), false);
    getConf().setBoolean(getConfKey(ContractOptions.SUPPORTS_UNIX_PERMISSIONS), false);
  } else if (ContractTestUtils.isOSX()) {
    //OSX HFS+ is not case sensitive
    getConf().setBoolean(getConfKey(ContractOptions.IS_CASE_SENSITIVE),
                         false);
  }
}
 

/** @return a string indicating which filesystem volume we're checking. */
public String getFilesystem() throws IOException {
  if (Shell.WINDOWS) {
    this.filesystem = dirFile.getCanonicalPath().substring(0, 2);
    return this.filesystem;
  } else {
    run();
    verifyExitCode();
    parseOutput();
    return filesystem;
  }
}
 

/**
 * Returns true if the argument is a file name that is testable on the platform
 * currently running the test.  This is intended for use by tests so that they
 * can skip checking file names that aren't supported by the underlying
 * platform.  The current implementation specifically checks for patterns that
 * are not valid file names on Windows when the tests are running on Windows.
 * 
 * @param fileName String file name to check
 * @return boolean true if the argument is valid as a file name
 */
private static boolean isTestableFileNameOnPlatform(String fileName) {
  boolean valid = true;

  if (Shell.WINDOWS) {
    // Disallow reserved characters: <, >, :, ", |, ?, *.
    // Disallow trailing space or period.
    // See http://msdn.microsoft.com/en-us/library/windows/desktop/aa365247(v=vs.85).aspx
    valid = !WIN_INVALID_FILE_NAME_PATTERN.matcher(fileName).matches();
  }

  return valid;
}
 

@Test (timeout = 30000)
public void testIsWindowsAbsolutePath() {
  if (!Shell.WINDOWS) return;
  assertTrue(Path.isWindowsAbsolutePath("C:\\test", false));
  assertTrue(Path.isWindowsAbsolutePath("C:/test", false));
  assertTrue(Path.isWindowsAbsolutePath("/C:/test", true));
  assertFalse(Path.isWindowsAbsolutePath("/test", false));
  assertFalse(Path.isWindowsAbsolutePath("/test", true));
  assertFalse(Path.isWindowsAbsolutePath("C:test", false));
  assertFalse(Path.isWindowsAbsolutePath("/C:test", true));
}
 

/**
 * Platform independent implementation for {@link File#setExecutable(boolean)}
 * File#setExecutable does not work as expected on Windows.
 * Note: revoking execute permission on folders does not have the same
 * behavior on Windows as on Unix platforms. Creating, deleting or renaming
 * a file within that folder will still succeed on Windows.
 * @param f input file
 * @param executable
 * @return true on success, false otherwise
 */
public static boolean setExecutable(File f, boolean executable) {
  if (Shell.WINDOWS) {
    try {
      String permission = executable ? "u+x" : "u-x";
      FileUtil.chmod(f.getCanonicalPath(), permission, false);
      return true;
    } catch (IOException ex) {
      return false;
    }
  } else {
    return f.setExecutable(executable);
  }
}
 

@Test(timeout=90000)
public void testContainerLaunchFailureHandling() throws Exception {
  String[] args = {
    "--jar",
    APPMASTER_JAR,
    "--num_containers",
    "2",
    "--shell_command",
    Shell.WINDOWS ? "dir" : "ls",
    "--master_memory",
    "512",
    "--container_memory",
    "128"
  };

  LOG.info("Initializing DS Client");
  Client client = new Client(ContainerLaunchFailAppMaster.class.getName(),
    new Configuration(yarnCluster.getConfig()));
  boolean initSuccess = client.init(args);
  Assert.assertTrue(initSuccess);
  LOG.info("Running DS Client");
  boolean result = client.run();

  LOG.info("Client run completed. Result=" + result);
  Assert.assertFalse(result);

}
 

Stat(String owner, String group, int mode) {
  if (!Shell.WINDOWS) {
    this.owner = owner;
  } else {
    this.owner = stripDomain(owner);
  }
  if (!Shell.WINDOWS) {
    this.group = group;
  } else {
    this.group = stripDomain(group);
  }
  this.mode = mode;
}
 

/**
 * Platform independent implementation for {@link File#canExecute()}
 * @param f input file
 * @return On Unix, same as {@link File#canExecute()}
 *         On Windows, true if process has execute access on the path
 */
public static boolean canExecute(File f) {
  if (Shell.WINDOWS) {
    try {
      return NativeIO.Windows.access(f.getCanonicalPath(),
          NativeIO.Windows.AccessRight.ACCESS_EXECUTE);
    } catch (IOException e) {
      return false;
    }
  } else {
    return f.canExecute();
  }
}