<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<!-- NewPage -->
<html lang="en">
<head>
<!-- Generated by javadoc (1.8.0_292) on Tue Jun 15 06:01:44 GMT 2021 -->
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>FileContext (Apache Hadoop Common 3.3.1 API)</title>
<meta name="date" content="2021-06-15">
<link rel="stylesheet" type="text/css" href="../../../../stylesheet.css" title="Style">
<script type="text/javascript" src="../../../../script.js"></script>
</head>
<body>
<script type="text/javascript"><!--
    try {
        if (location.href.indexOf('is-external=true') == -1) {
            parent.document.title="FileContext (Apache Hadoop Common 3.3.1 API)";
        }
    }
    catch(err) {
    }
//-->
var methods = {"i0":9,"i1":10,"i2":10,"i3":10,"i4":10,"i5":10,"i6":10,"i7":10,"i8":10,"i9":10,"i10":10,"i11":9,"i12":10,"i13":10,"i14":9,"i15":9,"i16":9,"i17":9,"i18":9,"i19":9,"i20":10,"i21":10,"i22":10,"i23":10,"i24":10,"i25":10,"i26":9,"i27":9,"i28":10,"i29":9,"i30":10,"i31":10,"i32":10,"i33":10,"i34":10,"i35":10,"i36":10,"i37":10,"i38":10,"i39":10,"i40":10,"i41":10,"i42":10,"i43":10,"i44":10,"i45":10,"i46":10,"i47":10,"i48":10,"i49":9,"i50":10,"i51":10,"i52":10,"i53":10,"i54":10,"i55":10,"i56":10,"i57":10,"i58":10,"i59":10,"i60":10,"i61":10,"i62":10,"i63":10,"i64":10,"i65":10,"i66":10,"i67":10,"i68":10,"i69":10,"i70":10,"i71":10,"i72":10,"i73":10};
var tabs = {65535:["t0","All Methods"],1:["t1","Static Methods"],2:["t2","Instance Methods"],8:["t4","Concrete Methods"]};
var altColor = "altColor";
var rowColor = "rowColor";
var tableTab = "tableTab";
var activeTableTab = "activeTableTab";
</script>
<noscript>
<div>JavaScript is disabled on your browser.</div>
</noscript>
<!-- ========= START OF TOP NAVBAR ======= -->
<div class="topNav"><a name="navbar.top">
<!--   -->
</a>
<div class="skipNav"><a href="#skip.navbar.top" title="Skip navigation links">Skip navigation links</a></div>
<a name="navbar.top.firstrow">
<!--   -->
</a>
<ul class="navList" title="Navigation">
<li><a href="../../../../overview-summary.html">Overview</a></li>
<li><a href="package-summary.html">Package</a></li>
<li class="navBarCell1Rev">Class</li>
<li><a href="class-use/FileContext.html">Use</a></li>
<li><a href="package-tree.html">Tree</a></li>
<li><a href="../../../../deprecated-list.html">Deprecated</a></li>
<li><a href="../../../../index-all.html">Index</a></li>
<li><a href="../../../../help-doc.html">Help</a></li>
</ul>
</div>
<div class="subNav">
<ul class="navList">
<li><a href="../../../../org/apache/hadoop/fs/FileChecksum.html" title="class in org.apache.hadoop.fs"><span class="typeNameLink">Prev&nbsp;Class</span></a></li>
<li><a href="../../../../org/apache/hadoop/fs/FileContext.Util.html" title="class in org.apache.hadoop.fs"><span class="typeNameLink">Next&nbsp;Class</span></a></li>
</ul>
<ul class="navList">
<li><a href="../../../../index.html?org/apache/hadoop/fs/FileContext.html" target="_top">Frames</a></li>
<li><a href="FileContext.html" target="_top">No&nbsp;Frames</a></li>
</ul>
<ul class="navList" id="allclasses_navbar_top">
<li><a href="../../../../allclasses-noframe.html">All&nbsp;Classes</a></li>
</ul>
<div>
<script type="text/javascript"><!--
  allClassesLink = document.getElementById("allclasses_navbar_top");
  if(window==top) {
    allClassesLink.style.display = "block";
  }
  else {
    allClassesLink.style.display = "none";
  }
  //-->
</script>
</div>
<div>
<ul class="subNavList">
<li>Summary:&nbsp;</li>
<li><a href="#nested.class.summary">Nested</a>&nbsp;|&nbsp;</li>
<li><a href="#field.summary">Field</a>&nbsp;|&nbsp;</li>
<li>Constr&nbsp;|&nbsp;</li>
<li><a href="#method.summary">Method</a></li>
</ul>
<ul class="subNavList">
<li>Detail:&nbsp;</li>
<li><a href="#field.detail">Field</a>&nbsp;|&nbsp;</li>
<li>Constr&nbsp;|&nbsp;</li>
<li><a href="#method.detail">Method</a></li>
</ul>
</div>
<a name="skip.navbar.top">
<!--   -->
</a></div>
<!-- ========= END OF TOP NAVBAR ========= -->
<!-- ======== START OF CLASS DATA ======== -->
<div class="header">
<div class="subTitle">org.apache.hadoop.fs</div>
<h2 title="Class FileContext" class="title">Class FileContext</h2>
</div>
<div class="contentContainer">
<ul class="inheritance">
<li><a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">java.lang.Object</a></li>
<li>
<ul class="inheritance">
<li>org.apache.hadoop.fs.FileContext</li>
</ul>
</li>
</ul>
<div class="description">
<ul class="blockList">
<li class="blockList">
<dl>
<dt>All Implemented Interfaces:</dt>
<dd><a href="../../../../org/apache/hadoop/fs/PathCapabilities.html" title="interface in org.apache.hadoop.fs">PathCapabilities</a></dd>
</dl>
<hr>
<br>
<pre>@InterfaceAudience.Public
 @InterfaceStability.Stable
public class <span class="typeNameLabel">FileContext</span>
extends <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>
implements <a href="../../../../org/apache/hadoop/fs/PathCapabilities.html" title="interface in org.apache.hadoop.fs">PathCapabilities</a></pre>
<div class="block">The FileContext class provides an interface for users of the Hadoop
 file system. It exposes a number of file system operations, e.g. create,
 open, list.
 
 <h2>Path Names</h2>
 
 The Hadoop file system supports a URI namespace and URI names. This enables
 multiple types of file systems to be referenced using fully-qualified URIs.
 Two common Hadoop file system implementations are
 <ul>
 <li>the local file system: file:///path
 <li>the HDFS file system: hdfs://nnAddress:nnPort/path
 </ul>
 
 The Hadoop file system also supports additional naming schemes besides URIs.
 Hadoop has the concept of a <i>default file system</i>, which implies a
 default URI scheme and authority. This enables <i>slash-relative names</i>
 relative to the default FS, which are more convenient for users and
 application writers. The default FS is typically set by the user's
 environment, though it can also be manually specified.
 <p>
 
 Hadoop also supports <i>working-directory-relative</i> names, which are paths
 relative to the current working directory (similar to Unix). The working
 directory can be in a different file system than the default FS.
 <p>
 Thus, Hadoop path names can be specified as one of the following:
 <ul>
 <li>a fully-qualified URI: scheme://authority/path (e.g.
 hdfs://nnAddress:nnPort/foo/bar)
 <li>a slash-relative name: path relative to the default file system (e.g.
 /foo/bar)
 <li>a working-directory-relative name: path relative to the working dir (e.g.
 foo/bar)
 </ul>
  Relative paths with scheme (scheme:foo/bar) are illegal.
  
 <h2>Role of FileContext and Configuration Defaults</h2>

 The FileContext is the analogue of per-process file-related state in Unix. It
 contains two properties:
 
 <ul>
 <li>the default file system (for resolving slash-relative names)
 <li>the umask (for file permissions)
 </ul>
 In general, these properties are obtained from the default configuration file
 in the user's environment (see <a href="../../../../org/apache/hadoop/conf/Configuration.html" title="class in org.apache.hadoop.conf"><code>Configuration</code></a>).
 
 Further file system properties are specified on the server-side. File system
 operations default to using these server-side defaults unless otherwise
 specified.
 <p>
 The file system related server-side defaults are:
  <ul>
  <li> the home directory (default is "/user/userName")
  <li> the initial wd (only for local fs)
  <li> replication factor
  <li> block size
  <li> buffer size
  <li> encryptDataTransfer 
  <li> checksum option. (checksumType and  bytesPerChecksum)
  </ul>

 <h2>Example Usage</h2>

 Example 1: use the default config read from the $HADOOP_CONFIG/core.xml.
   Unspecified values come from core-defaults.xml in the release jar.
  <ul>  
  <li> myFContext = FileContext.getFileContext(); // uses the default config
                                                // which has your default FS 
  <li>  myFContext.create(path, ...);
  <li>  myFContext.setWorkingDir(path);
  <li>  myFContext.open (path, ...);  
  <li>...
  </ul>  
 Example 2: Get a FileContext with a specific URI as the default FS
  <ul>  
  <li> myFContext = FileContext.getFileContext(URI);
  <li> myFContext.create(path, ...);
  <li>...
 </ul>
 Example 3: FileContext with local file system as the default
  <ul> 
  <li> myFContext = FileContext.getLocalFSFileContext();
  <li> myFContext.create(path, ...);
  <li> ...
  </ul> 
 Example 4: Use a specific config, ignoring $HADOOP_CONFIG
  Generally you should not need use a config unless you are doing
   <ul> 
   <li> configX = someConfigSomeOnePassedToYou;
   <li> myFContext = getFileContext(configX); // configX is not changed,
                                              // is passed down 
   <li> myFContext.create(path, ...);
   <li>...
  </ul></div>
</li>
</ul>
</div>
<div class="summary">
<ul class="blockList">
<li class="blockList">
<!-- ======== NESTED CLASS SUMMARY ======== -->
<ul class="blockList">
<li class="blockList"><a name="nested.class.summary">
<!--   -->
</a>
<h3>Nested Class Summary</h3>
<table class="memberSummary" border="0" cellpadding="3" cellspacing="0" summary="Nested Class Summary table, listing nested classes, and an explanation">
<caption><span>Nested Classes</span><span class="tabEnd">&nbsp;</span></caption>
<tr>
<th class="colFirst" scope="col">Modifier and Type</th>
<th class="colLast" scope="col">Class and Description</th>
</tr>
<tr class="altColor">
<td class="colFirst"><code>class&nbsp;</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../org/apache/hadoop/fs/FileContext.Util.html" title="class in org.apache.hadoop.fs">FileContext.Util</a></span></code>
<div class="block">Utility/library methods built over the basic FileContext methods.</div>
</td>
</tr>
</table>
</li>
</ul>
<!-- =========== FIELD SUMMARY =========== -->
<ul class="blockList">
<li class="blockList"><a name="field.summary">
<!--   -->
</a>
<h3>Field Summary</h3>
<table class="memberSummary" border="0" cellpadding="3" cellspacing="0" summary="Field Summary table, listing fields, and an explanation">
<caption><span>Fields</span><span class="tabEnd">&nbsp;</span></caption>
<tr>
<th class="colFirst" scope="col">Modifier and Type</th>
<th class="colLast" scope="col">Field and Description</th>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static <a href="../../../../org/apache/hadoop/fs/permission/FsPermission.html" title="class in org.apache.hadoop.fs.permission">FsPermission</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../org/apache/hadoop/fs/FileContext.html#DEFAULT_PERM">DEFAULT_PERM</a></span></code>
<div class="block">Default permission for directory and symlink
 In previous versions, this default permission was also used to
 create files, so files created end up with ugo+x permission.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static <a href="../../../../org/apache/hadoop/fs/permission/FsPermission.html" title="class in org.apache.hadoop.fs.permission">FsPermission</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../org/apache/hadoop/fs/FileContext.html#DIR_DEFAULT_PERM">DIR_DEFAULT_PERM</a></span></code>
<div class="block">Default permission for directory</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static <a href="../../../../org/apache/hadoop/fs/permission/FsPermission.html" title="class in org.apache.hadoop.fs.permission">FsPermission</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../org/apache/hadoop/fs/FileContext.html#FILE_DEFAULT_PERM">FILE_DEFAULT_PERM</a></span></code>
<div class="block">Default permission for file</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static org.slf4j.Logger</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../org/apache/hadoop/fs/FileContext.html#LOG">LOG</a></span></code>&nbsp;</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static int</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../org/apache/hadoop/fs/FileContext.html#SHUTDOWN_HOOK_PRIORITY">SHUTDOWN_HOOK_PRIORITY</a></span></code>
<div class="block">Priority of the FileContext shutdown hook.</div>
</td>
</tr>
</table>
</li>
</ul>
<!-- ========== METHOD SUMMARY =========== -->
<ul class="blockList">
<li class="blockList"><a name="method.summary">
<!--   -->
</a>
<h3>Method Summary</h3>
<table class="memberSummary" border="0" cellpadding="3" cellspacing="0" summary="Method Summary table, listing methods, and an explanation">
<caption><span id="t0" class="activeTableTab"><span>All Methods</span><span class="tabEnd">&nbsp;</span></span><span id="t1" class="tableTab"><span><a href="javascript:show(1);">Static Methods</a></span><span class="tabEnd">&nbsp;</span></span><span id="t2" class="tableTab"><span><a href="javascript:show(2);">Instance Methods</a></span><span class="tabEnd">&nbsp;</span></span><span id="t4" class="tableTab"><span><a href="javascript:show(8);">Concrete Methods</a></span><span class="tabEnd">&nbsp;</span></span></caption>
<tr>
<th class="colFirst" scope="col">Modifier and Type</th>
<th class="colLast" scope="col">Method and Description</th>
</tr>
<tr id="i0" class="altColor">
<td class="colFirst"><code>static void</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../org/apache/hadoop/fs/FileContext.html#clearStatistics--">clearStatistics</a></span>()</code>
<div class="block">Clears all the statistics stored in AbstractFileSystem, for all the file
 systems.</div>
</td>
</tr>
<tr id="i1" class="rowColor">
<td class="colFirst"><code><a href="../../../../org/apache/hadoop/fs/FSDataOutputStreamBuilder.html" title="class in org.apache.hadoop.fs">FSDataOutputStreamBuilder</a>&lt;<a href="../../../../org/apache/hadoop/fs/FSDataOutputStream.html" title="class in org.apache.hadoop.fs">FSDataOutputStream</a>,?&gt;</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../org/apache/hadoop/fs/FileContext.html#create-org.apache.hadoop.fs.Path-">create</a></span>(<a href="../../../../org/apache/hadoop/fs/Path.html" title="class in org.apache.hadoop.fs">Path</a>&nbsp;f)</code>
<div class="block">Create a <a href="../../../../org/apache/hadoop/fs/FSDataOutputStreamBuilder.html" title="class in org.apache.hadoop.fs"><code>FSDataOutputStreamBuilder</code></a> for creating or overwriting
 a file on indicated path.</div>
</td>
</tr>
<tr id="i2" class="altColor">
<td class="colFirst"><code><a href="../../../../org/apache/hadoop/fs/FSDataOutputStream.html" title="class in org.apache.hadoop.fs">FSDataOutputStream</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../org/apache/hadoop/fs/FileContext.html#create-org.apache.hadoop.fs.Path-java.util.EnumSet-org.apache.hadoop.fs.Options.CreateOpts...-">create</a></span>(<a href="../../../../org/apache/hadoop/fs/Path.html" title="class in org.apache.hadoop.fs">Path</a>&nbsp;f,
      <a href="https://docs.oracle.com/javase/8/docs/api/java/util/EnumSet.html?is-external=true" title="class or interface in java.util">EnumSet</a>&lt;<a href="../../../../org/apache/hadoop/fs/CreateFlag.html" title="enum in org.apache.hadoop.fs">CreateFlag</a>&gt;&nbsp;createFlag,
      <a href="../../../../org/apache/hadoop/fs/Options.CreateOpts.html" title="class in org.apache.hadoop.fs">Options.CreateOpts</a>...&nbsp;opts)</code>
<div class="block">Create or overwrite file on indicated path and returns an output stream for
 writing into the file.</div>
</td>
</tr>
<tr id="i3" class="rowColor">
<td class="colFirst"><code><a href="../../../../org/apache/hadoop/fs/MultipartUploaderBuilder.html" title="interface in org.apache.hadoop.fs">MultipartUploaderBuilder</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../org/apache/hadoop/fs/FileContext.html#createMultipartUploader-org.apache.hadoop.fs.Path-">createMultipartUploader</a></span>(<a href="../../../../org/apache/hadoop/fs/Path.html" title="class in org.apache.hadoop.fs">Path</a>&nbsp;basePath)</code>
<div class="block">Create a multipart uploader.</div>
</td>
</tr>
<tr id="i4" class="altColor">
<td class="colFirst"><code><a href="../../../../org/apache/hadoop/fs/Path.html" title="class in org.apache.hadoop.fs">Path</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../org/apache/hadoop/fs/FileContext.html#createSnapshot-org.apache.hadoop.fs.Path-">createSnapshot</a></span>(<a href="../../../../org/apache/hadoop/fs/Path.html" title="class in org.apache.hadoop.fs">Path</a>&nbsp;path)</code>
<div class="block">Create a snapshot with a default name.</div>
</td>
</tr>
<tr id="i5" class="rowColor">
<td class="colFirst"><code><a href="../../../../org/apache/hadoop/fs/Path.html" title="class in org.apache.hadoop.fs">Path</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../org/apache/hadoop/fs/FileContext.html#createSnapshot-org.apache.hadoop.fs.Path-java.lang.String-">createSnapshot</a></span>(<a href="../../../../org/apache/hadoop/fs/Path.html" title="class in org.apache.hadoop.fs">Path</a>&nbsp;path,
              <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&nbsp;snapshotName)</code>
<div class="block">Create a snapshot.</div>
</td>
</tr>
<tr id="i6" class="altColor">
<td class="colFirst"><code>void</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../org/apache/hadoop/fs/FileContext.html#createSymlink-org.apache.hadoop.fs.Path-org.apache.hadoop.fs.Path-boolean-">createSymlink</a></span>(<a href="../../../../org/apache/hadoop/fs/Path.html" title="class in org.apache.hadoop.fs">Path</a>&nbsp;target,
             <a href="../../../../org/apache/hadoop/fs/Path.html" title="class in org.apache.hadoop.fs">Path</a>&nbsp;link,
             boolean&nbsp;createParent)</code>
<div class="block">Creates a symbolic link to an existing file.</div>
</td>
</tr>
<tr id="i7" class="rowColor">
<td class="colFirst"><code>boolean</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../org/apache/hadoop/fs/FileContext.html#delete-org.apache.hadoop.fs.Path-boolean-">delete</a></span>(<a href="../../../../org/apache/hadoop/fs/Path.html" title="class in org.apache.hadoop.fs">Path</a>&nbsp;f,
      boolean&nbsp;recursive)</code>
<div class="block">Delete a file.</div>
</td>
</tr>
<tr id="i8" class="altColor">
<td class="colFirst"><code>boolean</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../org/apache/hadoop/fs/FileContext.html#deleteOnExit-org.apache.hadoop.fs.Path-">deleteOnExit</a></span>(<a href="../../../../org/apache/hadoop/fs/Path.html" title="class in org.apache.hadoop.fs">Path</a>&nbsp;f)</code>
<div class="block">Mark a path to be deleted on JVM shutdown.</div>
</td>
</tr>
<tr id="i9" class="rowColor">
<td class="colFirst"><code>void</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../org/apache/hadoop/fs/FileContext.html#deleteSnapshot-org.apache.hadoop.fs.Path-java.lang.String-">deleteSnapshot</a></span>(<a href="../../../../org/apache/hadoop/fs/Path.html" title="class in org.apache.hadoop.fs">Path</a>&nbsp;path,
              <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&nbsp;snapshotName)</code>
<div class="block">Delete a snapshot of a directory.</div>
</td>
</tr>
<tr id="i10" class="altColor">
<td class="colFirst"><code><a href="../../../../org/apache/hadoop/fs/permission/AclStatus.html" title="class in org.apache.hadoop.fs.permission">AclStatus</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../org/apache/hadoop/fs/FileContext.html#getAclStatus-org.apache.hadoop.fs.Path-">getAclStatus</a></span>(<a href="../../../../org/apache/hadoop/fs/Path.html" title="class in org.apache.hadoop.fs">Path</a>&nbsp;path)</code>
<div class="block">Gets the ACLs of files and directories.</div>
</td>
</tr>
<tr id="i11" class="rowColor">
<td class="colFirst"><code>static <a href="https://docs.oracle.com/javase/8/docs/api/java/util/Map.html?is-external=true" title="class or interface in java.util">Map</a>&lt;<a href="https://docs.oracle.com/javase/8/docs/api/java/net/URI.html?is-external=true" title="class or interface in java.net">URI</a>,<a href="../../../../org/apache/hadoop/fs/FileSystem.Statistics.html" title="class in org.apache.hadoop.fs">FileSystem.Statistics</a>&gt;</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../org/apache/hadoop/fs/FileContext.html#getAllStatistics--">getAllStatistics</a></span>()</code>&nbsp;</td>
</tr>
<tr id="i12" class="altColor">
<td class="colFirst"><code><a href="https://docs.oracle.com/javase/8/docs/api/java/util/Collection.html?is-external=true" title="class or interface in java.util">Collection</a>&lt;? extends <a href="../../../../org/apache/hadoop/fs/BlockStoragePolicySpi.html" title="interface in org.apache.hadoop.fs">BlockStoragePolicySpi</a>&gt;</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../org/apache/hadoop/fs/FileContext.html#getAllStoragePolicies--">getAllStoragePolicies</a></span>()</code>
<div class="block">Retrieve all the storage policies supported by this file system.</div>
</td>
</tr>
<tr id="i13" class="rowColor">
<td class="colFirst"><code><a href="../../../../org/apache/hadoop/fs/FileChecksum.html" title="class in org.apache.hadoop.fs">FileChecksum</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../org/apache/hadoop/fs/FileContext.html#getFileChecksum-org.apache.hadoop.fs.Path-">getFileChecksum</a></span>(<a href="../../../../org/apache/hadoop/fs/Path.html" title="class in org.apache.hadoop.fs">Path</a>&nbsp;f)</code>
<div class="block">Get the checksum of a file.</div>
</td>
</tr>
<tr id="i14" class="altColor">
<td class="colFirst"><code>static <a href="../../../../org/apache/hadoop/fs/FileContext.html" title="class in org.apache.hadoop.fs">FileContext</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../org/apache/hadoop/fs/FileContext.html#getFileContext--">getFileContext</a></span>()</code>
<div class="block">Create a FileContext using the default config read from the
 $HADOOP_CONFIG/core.xml, Unspecified key-values for config are defaulted
 from core-defaults.xml in the release jar.</div>
</td>
</tr>
<tr id="i15" class="rowColor">
<td class="colFirst"><code>protected static <a href="../../../../org/apache/hadoop/fs/FileContext.html" title="class in org.apache.hadoop.fs">FileContext</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../org/apache/hadoop/fs/FileContext.html#getFileContext-org.apache.hadoop.fs.AbstractFileSystem-">getFileContext</a></span>(<a href="../../../../org/apache/hadoop/fs/AbstractFileSystem.html" title="class in org.apache.hadoop.fs">AbstractFileSystem</a>&nbsp;defaultFS)</code>
<div class="block">Create a FileContext for specified file system using the default config.</div>
</td>
</tr>
<tr id="i16" class="altColor">
<td class="colFirst"><code>static <a href="../../../../org/apache/hadoop/fs/FileContext.html" title="class in org.apache.hadoop.fs">FileContext</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../org/apache/hadoop/fs/FileContext.html#getFileContext-org.apache.hadoop.fs.AbstractFileSystem-org.apache.hadoop.conf.Configuration-">getFileContext</a></span>(<a href="../../../../org/apache/hadoop/fs/AbstractFileSystem.html" title="class in org.apache.hadoop.fs">AbstractFileSystem</a>&nbsp;defFS,
              <a href="../../../../org/apache/hadoop/conf/Configuration.html" title="class in org.apache.hadoop.conf">Configuration</a>&nbsp;aConf)</code>
<div class="block">Create a FileContext with specified FS as default using the specified
 config.</div>
</td>
</tr>
<tr id="i17" class="rowColor">
<td class="colFirst"><code>static <a href="../../../../org/apache/hadoop/fs/FileContext.html" title="class in org.apache.hadoop.fs">FileContext</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../org/apache/hadoop/fs/FileContext.html#getFileContext-org.apache.hadoop.conf.Configuration-">getFileContext</a></span>(<a href="../../../../org/apache/hadoop/conf/Configuration.html" title="class in org.apache.hadoop.conf">Configuration</a>&nbsp;aConf)</code>
<div class="block">Create a FileContext using the passed config.</div>
</td>
</tr>
<tr id="i18" class="altColor">
<td class="colFirst"><code>static <a href="../../../../org/apache/hadoop/fs/FileContext.html" title="class in org.apache.hadoop.fs">FileContext</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../org/apache/hadoop/fs/FileContext.html#getFileContext-java.net.URI-">getFileContext</a></span>(<a href="https://docs.oracle.com/javase/8/docs/api/java/net/URI.html?is-external=true" title="class or interface in java.net">URI</a>&nbsp;defaultFsUri)</code>
<div class="block">Create a FileContext for specified URI using the default config.</div>
</td>
</tr>
<tr id="i19" class="rowColor">
<td class="colFirst"><code>static <a href="../../../../org/apache/hadoop/fs/FileContext.html" title="class in org.apache.hadoop.fs">FileContext</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../org/apache/hadoop/fs/FileContext.html#getFileContext-java.net.URI-org.apache.hadoop.conf.Configuration-">getFileContext</a></span>(<a href="https://docs.oracle.com/javase/8/docs/api/java/net/URI.html?is-external=true" title="class or interface in java.net">URI</a>&nbsp;defaultFsUri,
              <a href="../../../../org/apache/hadoop/conf/Configuration.html" title="class in org.apache.hadoop.conf">Configuration</a>&nbsp;aConf)</code>
<div class="block">Create a FileContext for specified default URI using the specified config.</div>
</td>
</tr>
<tr id="i20" class="altColor">
<td class="colFirst"><code><a href="../../../../org/apache/hadoop/fs/FileStatus.html" title="class in org.apache.hadoop.fs">FileStatus</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../org/apache/hadoop/fs/FileContext.html#getFileLinkStatus-org.apache.hadoop.fs.Path-">getFileLinkStatus</a></span>(<a href="../../../../org/apache/hadoop/fs/Path.html" title="class in org.apache.hadoop.fs">Path</a>&nbsp;f)</code>
<div class="block">Return a file status object that represents the path.</div>
</td>
</tr>
<tr id="i21" class="rowColor">
<td class="colFirst"><code><a href="../../../../org/apache/hadoop/fs/FileStatus.html" title="class in org.apache.hadoop.fs">FileStatus</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../org/apache/hadoop/fs/FileContext.html#getFileStatus-org.apache.hadoop.fs.Path-">getFileStatus</a></span>(<a href="../../../../org/apache/hadoop/fs/Path.html" title="class in org.apache.hadoop.fs">Path</a>&nbsp;f)</code>
<div class="block">Return a file status object that represents the path.</div>
</td>
</tr>
<tr id="i22" class="altColor">
<td class="colFirst"><code>protected <a href="../../../../org/apache/hadoop/fs/AbstractFileSystem.html" title="class in org.apache.hadoop.fs">AbstractFileSystem</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../org/apache/hadoop/fs/FileContext.html#getFSofPath-org.apache.hadoop.fs.Path-">getFSofPath</a></span>(<a href="../../../../org/apache/hadoop/fs/Path.html" title="class in org.apache.hadoop.fs">Path</a>&nbsp;absOrFqPath)</code>
<div class="block">Get the file system of supplied path.</div>
</td>
</tr>
<tr id="i23" class="rowColor">
<td class="colFirst"><code><a href="../../../../org/apache/hadoop/fs/FsStatus.html" title="class in org.apache.hadoop.fs">FsStatus</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../org/apache/hadoop/fs/FileContext.html#getFsStatus-org.apache.hadoop.fs.Path-">getFsStatus</a></span>(<a href="../../../../org/apache/hadoop/fs/Path.html" title="class in org.apache.hadoop.fs">Path</a>&nbsp;f)</code>
<div class="block">Returns a status object describing the use and capacity of the
 file system denoted by the Parh argument p.</div>
</td>
</tr>
<tr id="i24" class="altColor">
<td class="colFirst"><code><a href="../../../../org/apache/hadoop/fs/Path.html" title="class in org.apache.hadoop.fs">Path</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../org/apache/hadoop/fs/FileContext.html#getHomeDirectory--">getHomeDirectory</a></span>()</code>
<div class="block">Return the current user's home directory in this file system.</div>
</td>
</tr>
<tr id="i25" class="rowColor">
<td class="colFirst"><code><a href="../../../../org/apache/hadoop/fs/Path.html" title="class in org.apache.hadoop.fs">Path</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../org/apache/hadoop/fs/FileContext.html#getLinkTarget-org.apache.hadoop.fs.Path-">getLinkTarget</a></span>(<a href="../../../../org/apache/hadoop/fs/Path.html" title="class in org.apache.hadoop.fs">Path</a>&nbsp;f)</code>
<div class="block">Returns the target of the given symbolic link as it was specified
 when the link was created.</div>
</td>
</tr>
<tr id="i26" class="altColor">
<td class="colFirst"><code>static <a href="../../../../org/apache/hadoop/fs/FileContext.html" title="class in org.apache.hadoop.fs">FileContext</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../org/apache/hadoop/fs/FileContext.html#getLocalFSFileContext--">getLocalFSFileContext</a></span>()</code>&nbsp;</td>
</tr>
<tr id="i27" class="rowColor">
<td class="colFirst"><code>static <a href="../../../../org/apache/hadoop/fs/FileContext.html" title="class in org.apache.hadoop.fs">FileContext</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../org/apache/hadoop/fs/FileContext.html#getLocalFSFileContext-org.apache.hadoop.conf.Configuration-">getLocalFSFileContext</a></span>(<a href="../../../../org/apache/hadoop/conf/Configuration.html" title="class in org.apache.hadoop.conf">Configuration</a>&nbsp;aConf)</code>&nbsp;</td>
</tr>
<tr id="i28" class="altColor">
<td class="colFirst"><code><a href="../../../../org/apache/hadoop/fs/FsServerDefaults.html" title="class in org.apache.hadoop.fs">FsServerDefaults</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../org/apache/hadoop/fs/FileContext.html#getServerDefaults-org.apache.hadoop.fs.Path-">getServerDefaults</a></span>(<a href="../../../../org/apache/hadoop/fs/Path.html" title="class in org.apache.hadoop.fs">Path</a>&nbsp;path)</code>
<div class="block">Return a set of server default configuration values based on path.</div>
</td>
</tr>
<tr id="i29" class="rowColor">
<td class="colFirst"><code>static <a href="../../../../org/apache/hadoop/fs/FileSystem.Statistics.html" title="class in org.apache.hadoop.fs">FileSystem.Statistics</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../org/apache/hadoop/fs/FileContext.html#getStatistics-java.net.URI-">getStatistics</a></span>(<a href="https://docs.oracle.com/javase/8/docs/api/java/net/URI.html?is-external=true" title="class or interface in java.net">URI</a>&nbsp;uri)</code>
<div class="block">Get the statistics for a particular file system</div>
</td>
</tr>
<tr id="i30" class="altColor">
<td class="colFirst"><code><a href="../../../../org/apache/hadoop/fs/BlockStoragePolicySpi.html" title="interface in org.apache.hadoop.fs">BlockStoragePolicySpi</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../org/apache/hadoop/fs/FileContext.html#getStoragePolicy-org.apache.hadoop.fs.Path-">getStoragePolicy</a></span>(<a href="../../../../org/apache/hadoop/fs/Path.html" title="class in org.apache.hadoop.fs">Path</a>&nbsp;path)</code>
<div class="block">Query the effective storage policy ID for the given file or directory.</div>
</td>
</tr>
<tr id="i31" class="rowColor">
<td class="colFirst"><code><a href="../../../../org/apache/hadoop/security/UserGroupInformation.html" title="class in org.apache.hadoop.security">UserGroupInformation</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../org/apache/hadoop/fs/FileContext.html#getUgi--">getUgi</a></span>()</code>
<div class="block">Gets the ugi in the file-context</div>
</td>
</tr>
<tr id="i32" class="altColor">
<td class="colFirst"><code><a href="../../../../org/apache/hadoop/fs/permission/FsPermission.html" title="class in org.apache.hadoop.fs.permission">FsPermission</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../org/apache/hadoop/fs/FileContext.html#getUMask--">getUMask</a></span>()</code>&nbsp;</td>
</tr>
<tr id="i33" class="rowColor">
<td class="colFirst"><code><a href="../../../../org/apache/hadoop/fs/Path.html" title="class in org.apache.hadoop.fs">Path</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../org/apache/hadoop/fs/FileContext.html#getWorkingDirectory--">getWorkingDirectory</a></span>()</code>
<div class="block">Gets the working directory for wd-relative names (such a "foo/bar").</div>
</td>
</tr>
<tr id="i34" class="altColor">
<td class="colFirst"><code>byte[]</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../org/apache/hadoop/fs/FileContext.html#getXAttr-org.apache.hadoop.fs.Path-java.lang.String-">getXAttr</a></span>(<a href="../../../../org/apache/hadoop/fs/Path.html" title="class in org.apache.hadoop.fs">Path</a>&nbsp;path,
        <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&nbsp;name)</code>
<div class="block">Get an xattr for a file or directory.</div>
</td>
</tr>
<tr id="i35" class="rowColor">
<td class="colFirst"><code><a href="https://docs.oracle.com/javase/8/docs/api/java/util/Map.html?is-external=true" title="class or interface in java.util">Map</a>&lt;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>,byte[]&gt;</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../org/apache/hadoop/fs/FileContext.html#getXAttrs-org.apache.hadoop.fs.Path-">getXAttrs</a></span>(<a href="../../../../org/apache/hadoop/fs/Path.html" title="class in org.apache.hadoop.fs">Path</a>&nbsp;path)</code>
<div class="block">Get all of the xattrs for a file or directory.</div>
</td>
</tr>
<tr id="i36" class="altColor">
<td class="colFirst"><code><a href="https://docs.oracle.com/javase/8/docs/api/java/util/Map.html?is-external=true" title="class or interface in java.util">Map</a>&lt;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>,byte[]&gt;</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../org/apache/hadoop/fs/FileContext.html#getXAttrs-org.apache.hadoop.fs.Path-java.util.List-">getXAttrs</a></span>(<a href="../../../../org/apache/hadoop/fs/Path.html" title="class in org.apache.hadoop.fs">Path</a>&nbsp;path,
         <a href="https://docs.oracle.com/javase/8/docs/api/java/util/List.html?is-external=true" title="class or interface in java.util">List</a>&lt;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&gt;&nbsp;names)</code>
<div class="block">Get all of the xattrs for a file or directory.</div>
</td>
</tr>
<tr id="i37" class="rowColor">
<td class="colFirst"><code>boolean</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../org/apache/hadoop/fs/FileContext.html#hasPathCapability-org.apache.hadoop.fs.Path-java.lang.String-">hasPathCapability</a></span>(<a href="../../../../org/apache/hadoop/fs/Path.html" title="class in org.apache.hadoop.fs">Path</a>&nbsp;path,
                 <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&nbsp;capability)</code>
<div class="block">Return the path capabilities of the bonded <code>AbstractFileSystem</code>.</div>
</td>
</tr>
<tr id="i38" class="altColor">
<td class="colFirst"><code><a href="../../../../org/apache/hadoop/fs/RemoteIterator.html" title="interface in org.apache.hadoop.fs">RemoteIterator</a>&lt;<a href="../../../../org/apache/hadoop/fs/Path.html" title="class in org.apache.hadoop.fs">Path</a>&gt;</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../org/apache/hadoop/fs/FileContext.html#listCorruptFileBlocks-org.apache.hadoop.fs.Path-">listCorruptFileBlocks</a></span>(<a href="../../../../org/apache/hadoop/fs/Path.html" title="class in org.apache.hadoop.fs">Path</a>&nbsp;path)</code>&nbsp;</td>
</tr>
<tr id="i39" class="rowColor">
<td class="colFirst"><code><a href="../../../../org/apache/hadoop/fs/RemoteIterator.html" title="interface in org.apache.hadoop.fs">RemoteIterator</a>&lt;<a href="../../../../org/apache/hadoop/fs/LocatedFileStatus.html" title="class in org.apache.hadoop.fs">LocatedFileStatus</a>&gt;</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../org/apache/hadoop/fs/FileContext.html#listLocatedStatus-org.apache.hadoop.fs.Path-">listLocatedStatus</a></span>(<a href="../../../../org/apache/hadoop/fs/Path.html" title="class in org.apache.hadoop.fs">Path</a>&nbsp;f)</code>
<div class="block">List the statuses of the files/directories in the given path if the path is
 a directory.</div>
</td>
</tr>
<tr id="i40" class="altColor">
<td class="colFirst"><code><a href="../../../../org/apache/hadoop/fs/RemoteIterator.html" title="interface in org.apache.hadoop.fs">RemoteIterator</a>&lt;<a href="../../../../org/apache/hadoop/fs/FileStatus.html" title="class in org.apache.hadoop.fs">FileStatus</a>&gt;</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../org/apache/hadoop/fs/FileContext.html#listStatus-org.apache.hadoop.fs.Path-">listStatus</a></span>(<a href="../../../../org/apache/hadoop/fs/Path.html" title="class in org.apache.hadoop.fs">Path</a>&nbsp;f)</code>
<div class="block">List the statuses of the files/directories in the given path if the path is
 a directory.</div>
</td>
</tr>
<tr id="i41" class="rowColor">
<td class="colFirst"><code><a href="https://docs.oracle.com/javase/8/docs/api/java/util/List.html?is-external=true" title="class or interface in java.util">List</a>&lt;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&gt;</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../org/apache/hadoop/fs/FileContext.html#listXAttrs-org.apache.hadoop.fs.Path-">listXAttrs</a></span>(<a href="../../../../org/apache/hadoop/fs/Path.html" title="class in org.apache.hadoop.fs">Path</a>&nbsp;path)</code>
<div class="block">Get all of the xattr names for a file or directory.</div>
</td>
</tr>
<tr id="i42" class="altColor">
<td class="colFirst"><code><a href="../../../../org/apache/hadoop/fs/Path.html" title="class in org.apache.hadoop.fs">Path</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../org/apache/hadoop/fs/FileContext.html#makeQualified-org.apache.hadoop.fs.Path-">makeQualified</a></span>(<a href="../../../../org/apache/hadoop/fs/Path.html" title="class in org.apache.hadoop.fs">Path</a>&nbsp;path)</code>
<div class="block">Make the path fully qualified if it is isn't.</div>
</td>
</tr>
<tr id="i43" class="rowColor">
<td class="colFirst"><code>void</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../org/apache/hadoop/fs/FileContext.html#mkdir-org.apache.hadoop.fs.Path-org.apache.hadoop.fs.permission.FsPermission-boolean-">mkdir</a></span>(<a href="../../../../org/apache/hadoop/fs/Path.html" title="class in org.apache.hadoop.fs">Path</a>&nbsp;dir,
     <a href="../../../../org/apache/hadoop/fs/permission/FsPermission.html" title="class in org.apache.hadoop.fs.permission">FsPermission</a>&nbsp;permission,
     boolean&nbsp;createParent)</code>
<div class="block">Make(create) a directory and all the non-existent parents.</div>
</td>
</tr>
<tr id="i44" class="altColor">
<td class="colFirst"><code>void</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../org/apache/hadoop/fs/FileContext.html#modifyAclEntries-org.apache.hadoop.fs.Path-java.util.List-">modifyAclEntries</a></span>(<a href="../../../../org/apache/hadoop/fs/Path.html" title="class in org.apache.hadoop.fs">Path</a>&nbsp;path,
                <a href="https://docs.oracle.com/javase/8/docs/api/java/util/List.html?is-external=true" title="class or interface in java.util">List</a>&lt;<a href="../../../../org/apache/hadoop/fs/permission/AclEntry.html" title="class in org.apache.hadoop.fs.permission">AclEntry</a>&gt;&nbsp;aclSpec)</code>
<div class="block">Modifies ACL entries of files and directories.</div>
</td>
</tr>
<tr id="i45" class="rowColor">
<td class="colFirst"><code>void</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../org/apache/hadoop/fs/FileContext.html#msync--">msync</a></span>()</code>
<div class="block">Synchronize client metadata state.</div>
</td>
</tr>
<tr id="i46" class="altColor">
<td class="colFirst"><code><a href="../../../../org/apache/hadoop/fs/FSDataInputStream.html" title="class in org.apache.hadoop.fs">FSDataInputStream</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../org/apache/hadoop/fs/FileContext.html#open-org.apache.hadoop.fs.Path-">open</a></span>(<a href="../../../../org/apache/hadoop/fs/Path.html" title="class in org.apache.hadoop.fs">Path</a>&nbsp;f)</code>
<div class="block">Opens an FSDataInputStream at the indicated Path using
 default buffersize.</div>
</td>
</tr>
<tr id="i47" class="rowColor">
<td class="colFirst"><code><a href="../../../../org/apache/hadoop/fs/FSDataInputStream.html" title="class in org.apache.hadoop.fs">FSDataInputStream</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../org/apache/hadoop/fs/FileContext.html#open-org.apache.hadoop.fs.Path-int-">open</a></span>(<a href="../../../../org/apache/hadoop/fs/Path.html" title="class in org.apache.hadoop.fs">Path</a>&nbsp;f,
    int&nbsp;bufferSize)</code>
<div class="block">Opens an FSDataInputStream at the indicated Path.</div>
</td>
</tr>
<tr id="i48" class="altColor">
<td class="colFirst"><code><a href="../../../../org/apache/hadoop/fs/FutureDataInputStreamBuilder.html" title="interface in org.apache.hadoop.fs">FutureDataInputStreamBuilder</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../org/apache/hadoop/fs/FileContext.html#openFile-org.apache.hadoop.fs.Path-">openFile</a></span>(<a href="../../../../org/apache/hadoop/fs/Path.html" title="class in org.apache.hadoop.fs">Path</a>&nbsp;path)</code>
<div class="block">Open a file for reading through a builder API.</div>
</td>
</tr>
<tr id="i49" class="rowColor">
<td class="colFirst"><code>static void</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../org/apache/hadoop/fs/FileContext.html#printStatistics--">printStatistics</a></span>()</code>
<div class="block">Prints the statistics to standard output.</div>
</td>
</tr>
<tr id="i50" class="altColor">
<td class="colFirst"><code>void</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../org/apache/hadoop/fs/FileContext.html#removeAcl-org.apache.hadoop.fs.Path-">removeAcl</a></span>(<a href="../../../../org/apache/hadoop/fs/Path.html" title="class in org.apache.hadoop.fs">Path</a>&nbsp;path)</code>
<div class="block">Removes all but the base ACL entries of files and directories.</div>
</td>
</tr>
<tr id="i51" class="rowColor">
<td class="colFirst"><code>void</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../org/apache/hadoop/fs/FileContext.html#removeAclEntries-org.apache.hadoop.fs.Path-java.util.List-">removeAclEntries</a></span>(<a href="../../../../org/apache/hadoop/fs/Path.html" title="class in org.apache.hadoop.fs">Path</a>&nbsp;path,
                <a href="https://docs.oracle.com/javase/8/docs/api/java/util/List.html?is-external=true" title="class or interface in java.util">List</a>&lt;<a href="../../../../org/apache/hadoop/fs/permission/AclEntry.html" title="class in org.apache.hadoop.fs.permission">AclEntry</a>&gt;&nbsp;aclSpec)</code>
<div class="block">Removes ACL entries from files and directories.</div>
</td>
</tr>
<tr id="i52" class="altColor">
<td class="colFirst"><code>void</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../org/apache/hadoop/fs/FileContext.html#removeDefaultAcl-org.apache.hadoop.fs.Path-">removeDefaultAcl</a></span>(<a href="../../../../org/apache/hadoop/fs/Path.html" title="class in org.apache.hadoop.fs">Path</a>&nbsp;path)</code>
<div class="block">Removes all default ACL entries from files and directories.</div>
</td>
</tr>
<tr id="i53" class="rowColor">
<td class="colFirst"><code>void</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../org/apache/hadoop/fs/FileContext.html#removeXAttr-org.apache.hadoop.fs.Path-java.lang.String-">removeXAttr</a></span>(<a href="../../../../org/apache/hadoop/fs/Path.html" title="class in org.apache.hadoop.fs">Path</a>&nbsp;path,
           <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&nbsp;name)</code>
<div class="block">Remove an xattr of a file or directory.</div>
</td>
</tr>
<tr id="i54" class="altColor">
<td class="colFirst"><code>void</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../org/apache/hadoop/fs/FileContext.html#rename-org.apache.hadoop.fs.Path-org.apache.hadoop.fs.Path-org.apache.hadoop.fs.Options.Rename...-">rename</a></span>(<a href="../../../../org/apache/hadoop/fs/Path.html" title="class in org.apache.hadoop.fs">Path</a>&nbsp;src,
      <a href="../../../../org/apache/hadoop/fs/Path.html" title="class in org.apache.hadoop.fs">Path</a>&nbsp;dst,
      <a href="../../../../org/apache/hadoop/fs/Options.Rename.html" title="enum in org.apache.hadoop.fs">Options.Rename</a>...&nbsp;options)</code>
<div class="block">Renames Path src to Path dst
 
 Fails if src is a file and dst is a directory.</div>
</td>
</tr>
<tr id="i55" class="rowColor">
<td class="colFirst"><code>void</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../org/apache/hadoop/fs/FileContext.html#renameSnapshot-org.apache.hadoop.fs.Path-java.lang.String-java.lang.String-">renameSnapshot</a></span>(<a href="../../../../org/apache/hadoop/fs/Path.html" title="class in org.apache.hadoop.fs">Path</a>&nbsp;path,
              <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&nbsp;snapshotOldName,
              <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&nbsp;snapshotNewName)</code>
<div class="block">Rename a snapshot.</div>
</td>
</tr>
<tr id="i56" class="altColor">
<td class="colFirst"><code>protected <a href="../../../../org/apache/hadoop/fs/Path.html" title="class in org.apache.hadoop.fs">Path</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../org/apache/hadoop/fs/FileContext.html#resolve-org.apache.hadoop.fs.Path-">resolve</a></span>(<a href="../../../../org/apache/hadoop/fs/Path.html" title="class in org.apache.hadoop.fs">Path</a>&nbsp;f)</code>
<div class="block">Resolves all symbolic links in the specified path.</div>
</td>
</tr>
<tr id="i57" class="rowColor">
<td class="colFirst"><code>protected <a href="../../../../org/apache/hadoop/fs/Path.html" title="class in org.apache.hadoop.fs">Path</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../org/apache/hadoop/fs/FileContext.html#resolveIntermediate-org.apache.hadoop.fs.Path-">resolveIntermediate</a></span>(<a href="../../../../org/apache/hadoop/fs/Path.html" title="class in org.apache.hadoop.fs">Path</a>&nbsp;f)</code>
<div class="block">Resolves all symbolic links in the specified path leading up 
 to, but not including the final path component.</div>
</td>
</tr>
<tr id="i58" class="altColor">
<td class="colFirst"><code><a href="../../../../org/apache/hadoop/fs/Path.html" title="class in org.apache.hadoop.fs">Path</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../org/apache/hadoop/fs/FileContext.html#resolvePath-org.apache.hadoop.fs.Path-">resolvePath</a></span>(<a href="../../../../org/apache/hadoop/fs/Path.html" title="class in org.apache.hadoop.fs">Path</a>&nbsp;f)</code>
<div class="block">Resolve the path following any symlinks or mount points</div>
</td>
</tr>
<tr id="i59" class="rowColor">
<td class="colFirst"><code>void</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../org/apache/hadoop/fs/FileContext.html#satisfyStoragePolicy-org.apache.hadoop.fs.Path-">satisfyStoragePolicy</a></span>(<a href="../../../../org/apache/hadoop/fs/Path.html" title="class in org.apache.hadoop.fs">Path</a>&nbsp;path)</code>
<div class="block">Set the source path to satisfy storage policy.</div>
</td>
</tr>
<tr id="i60" class="altColor">
<td class="colFirst"><code>void</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../org/apache/hadoop/fs/FileContext.html#setAcl-org.apache.hadoop.fs.Path-java.util.List-">setAcl</a></span>(<a href="../../../../org/apache/hadoop/fs/Path.html" title="class in org.apache.hadoop.fs">Path</a>&nbsp;path,
      <a href="https://docs.oracle.com/javase/8/docs/api/java/util/List.html?is-external=true" title="class or interface in java.util">List</a>&lt;<a href="../../../../org/apache/hadoop/fs/permission/AclEntry.html" title="class in org.apache.hadoop.fs.permission">AclEntry</a>&gt;&nbsp;aclSpec)</code>
<div class="block">Fully replaces ACL of files and directories, discarding all existing
 entries.</div>
</td>
</tr>
<tr id="i61" class="rowColor">
<td class="colFirst"><code>void</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../org/apache/hadoop/fs/FileContext.html#setOwner-org.apache.hadoop.fs.Path-java.lang.String-java.lang.String-">setOwner</a></span>(<a href="../../../../org/apache/hadoop/fs/Path.html" title="class in org.apache.hadoop.fs">Path</a>&nbsp;f,
        <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&nbsp;username,
        <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&nbsp;groupname)</code>
<div class="block">Set owner of a path (i.e.</div>
</td>
</tr>
<tr id="i62" class="altColor">
<td class="colFirst"><code>void</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../org/apache/hadoop/fs/FileContext.html#setPermission-org.apache.hadoop.fs.Path-org.apache.hadoop.fs.permission.FsPermission-">setPermission</a></span>(<a href="../../../../org/apache/hadoop/fs/Path.html" title="class in org.apache.hadoop.fs">Path</a>&nbsp;f,
             <a href="../../../../org/apache/hadoop/fs/permission/FsPermission.html" title="class in org.apache.hadoop.fs.permission">FsPermission</a>&nbsp;permission)</code>
<div class="block">Set permission of a path.</div>
</td>
</tr>
<tr id="i63" class="rowColor">
<td class="colFirst"><code>boolean</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../org/apache/hadoop/fs/FileContext.html#setReplication-org.apache.hadoop.fs.Path-short-">setReplication</a></span>(<a href="../../../../org/apache/hadoop/fs/Path.html" title="class in org.apache.hadoop.fs">Path</a>&nbsp;f,
              short&nbsp;replication)</code>
<div class="block">Set replication for an existing file.</div>
</td>
</tr>
<tr id="i64" class="altColor">
<td class="colFirst"><code>void</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../org/apache/hadoop/fs/FileContext.html#setStoragePolicy-org.apache.hadoop.fs.Path-java.lang.String-">setStoragePolicy</a></span>(<a href="../../../../org/apache/hadoop/fs/Path.html" title="class in org.apache.hadoop.fs">Path</a>&nbsp;path,
                <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&nbsp;policyName)</code>
<div class="block">Set the storage policy for a given file or directory.</div>
</td>
</tr>
<tr id="i65" class="rowColor">
<td class="colFirst"><code>void</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../org/apache/hadoop/fs/FileContext.html#setTimes-org.apache.hadoop.fs.Path-long-long-">setTimes</a></span>(<a href="../../../../org/apache/hadoop/fs/Path.html" title="class in org.apache.hadoop.fs">Path</a>&nbsp;f,
        long&nbsp;mtime,
        long&nbsp;atime)</code>
<div class="block">Set access time of a file.</div>
</td>
</tr>
<tr id="i66" class="altColor">
<td class="colFirst"><code>void</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../org/apache/hadoop/fs/FileContext.html#setUMask-org.apache.hadoop.fs.permission.FsPermission-">setUMask</a></span>(<a href="../../../../org/apache/hadoop/fs/permission/FsPermission.html" title="class in org.apache.hadoop.fs.permission">FsPermission</a>&nbsp;newUmask)</code>
<div class="block">Set umask to the supplied parameter.</div>
</td>
</tr>
<tr id="i67" class="rowColor">
<td class="colFirst"><code>void</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../org/apache/hadoop/fs/FileContext.html#setVerifyChecksum-boolean-org.apache.hadoop.fs.Path-">setVerifyChecksum</a></span>(boolean&nbsp;verifyChecksum,
                 <a href="../../../../org/apache/hadoop/fs/Path.html" title="class in org.apache.hadoop.fs">Path</a>&nbsp;f)</code>
<div class="block">Set the verify checksum flag for the  file system denoted by the path.</div>
</td>
</tr>
<tr id="i68" class="altColor">
<td class="colFirst"><code>void</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../org/apache/hadoop/fs/FileContext.html#setWorkingDirectory-org.apache.hadoop.fs.Path-">setWorkingDirectory</a></span>(<a href="../../../../org/apache/hadoop/fs/Path.html" title="class in org.apache.hadoop.fs">Path</a>&nbsp;newWDir)</code>
<div class="block">Set the working directory for wd-relative names (such a "foo/bar").</div>
</td>
</tr>
<tr id="i69" class="rowColor">
<td class="colFirst"><code>void</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../org/apache/hadoop/fs/FileContext.html#setXAttr-org.apache.hadoop.fs.Path-java.lang.String-byte:A-">setXAttr</a></span>(<a href="../../../../org/apache/hadoop/fs/Path.html" title="class in org.apache.hadoop.fs">Path</a>&nbsp;path,
        <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&nbsp;name,
        byte[]&nbsp;value)</code>
<div class="block">Set an xattr of a file or directory.</div>
</td>
</tr>
<tr id="i70" class="altColor">
<td class="colFirst"><code>void</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../org/apache/hadoop/fs/FileContext.html#setXAttr-org.apache.hadoop.fs.Path-java.lang.String-byte:A-java.util.EnumSet-">setXAttr</a></span>(<a href="../../../../org/apache/hadoop/fs/Path.html" title="class in org.apache.hadoop.fs">Path</a>&nbsp;path,
        <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&nbsp;name,
        byte[]&nbsp;value,
        <a href="https://docs.oracle.com/javase/8/docs/api/java/util/EnumSet.html?is-external=true" title="class or interface in java.util">EnumSet</a>&lt;<a href="../../../../org/apache/hadoop/fs/XAttrSetFlag.html" title="enum in org.apache.hadoop.fs">XAttrSetFlag</a>&gt;&nbsp;flag)</code>
<div class="block">Set an xattr of a file or directory.</div>
</td>
</tr>
<tr id="i71" class="rowColor">
<td class="colFirst"><code>boolean</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../org/apache/hadoop/fs/FileContext.html#truncate-org.apache.hadoop.fs.Path-long-">truncate</a></span>(<a href="../../../../org/apache/hadoop/fs/Path.html" title="class in org.apache.hadoop.fs">Path</a>&nbsp;f,
        long&nbsp;newLength)</code>
<div class="block">Truncate the file in the indicated path to the indicated size.</div>
</td>
</tr>
<tr id="i72" class="altColor">
<td class="colFirst"><code>void</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../org/apache/hadoop/fs/FileContext.html#unsetStoragePolicy-org.apache.hadoop.fs.Path-">unsetStoragePolicy</a></span>(<a href="../../../../org/apache/hadoop/fs/Path.html" title="class in org.apache.hadoop.fs">Path</a>&nbsp;src)</code>
<div class="block">Unset the storage policy set for a given file or directory.</div>
</td>
</tr>
<tr id="i73" class="rowColor">
<td class="colFirst"><code><a href="../../../../org/apache/hadoop/fs/FileContext.Util.html" title="class in org.apache.hadoop.fs">FileContext.Util</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../org/apache/hadoop/fs/FileContext.html#util--">util</a></span>()</code>&nbsp;</td>
</tr>
</table>
<ul class="blockList">
<li class="blockList"><a name="methods.inherited.from.class.java.lang.Object">
<!--   -->
</a>
<h3>Methods inherited from class&nbsp;java.lang.<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a></h3>
<code><a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html?is-external=true#clone--" title="class or interface in java.lang">clone</a>, <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html?is-external=true#equals-java.lang.Object-" title="class or interface in java.lang">equals</a>, <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html?is-external=true#finalize--" title="class or interface in java.lang">finalize</a>, <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html?is-external=true#getClass--" title="class or interface in java.lang">getClass</a>, <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html?is-external=true#hashCode--" title="class or interface in java.lang">hashCode</a>, <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html?is-external=true#notify--" title="class or interface in java.lang">notify</a>, <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html?is-external=true#notifyAll--" title="class or interface in java.lang">notifyAll</a>, <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html?is-external=true#toString--" title="class or interface in java.lang">toString</a>, <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html?is-external=true#wait--" title="class or interface in java.lang">wait</a>, <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html?is-external=true#wait-long-" title="class or interface in java.lang">wait</a>, <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html?is-external=true#wait-long-int-" title="class or interface in java.lang">wait</a></code></li>
</ul>
</li>
</ul>
</li>
</ul>
</div>
<div class="details">
<ul class="blockList">
<li class="blockList">
<!-- ============ FIELD DETAIL =========== -->
<ul class="blockList">
<li class="blockList"><a name="field.detail">
<!--   -->
</a>
<h3>Field Detail</h3>
<a name="LOG">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>LOG</h4>
<pre>public static final&nbsp;org.slf4j.Logger LOG</pre>
</li>
</ul>
<a name="DEFAULT_PERM">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>DEFAULT_PERM</h4>
<pre>public static final&nbsp;<a href="../../../../org/apache/hadoop/fs/permission/FsPermission.html" title="class in org.apache.hadoop.fs.permission">FsPermission</a> DEFAULT_PERM</pre>
<div class="block">Default permission for directory and symlink
 In previous versions, this default permission was also used to
 create files, so files created end up with ugo+x permission.
 See HADOOP-9155 for detail. 
 Two new constants are added to solve this, please use 
 <a href="../../../../org/apache/hadoop/fs/FileContext.html#DIR_DEFAULT_PERM"><code>DIR_DEFAULT_PERM</code></a> for directory, and use
 <a href="../../../../org/apache/hadoop/fs/FileContext.html#FILE_DEFAULT_PERM"><code>FILE_DEFAULT_PERM</code></a> for file.
 This constant is kept for compatibility.</div>
</li>
</ul>
<a name="DIR_DEFAULT_PERM">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>DIR_DEFAULT_PERM</h4>
<pre>public static final&nbsp;<a href="../../../../org/apache/hadoop/fs/permission/FsPermission.html" title="class in org.apache.hadoop.fs.permission">FsPermission</a> DIR_DEFAULT_PERM</pre>
<div class="block">Default permission for directory</div>
</li>
</ul>
<a name="FILE_DEFAULT_PERM">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>FILE_DEFAULT_PERM</h4>
<pre>public static final&nbsp;<a href="../../../../org/apache/hadoop/fs/permission/FsPermission.html" title="class in org.apache.hadoop.fs.permission">FsPermission</a> FILE_DEFAULT_PERM</pre>
<div class="block">Default permission for file</div>
</li>
</ul>
<a name="SHUTDOWN_HOOK_PRIORITY">
<!--   -->
</a>
<ul class="blockListLast">
<li class="blockList">
<h4>SHUTDOWN_HOOK_PRIORITY</h4>
<pre>public static final&nbsp;int SHUTDOWN_HOOK_PRIORITY</pre>
<div class="block">Priority of the FileContext shutdown hook.</div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../../constant-values.html#org.apache.hadoop.fs.FileContext.SHUTDOWN_HOOK_PRIORITY">Constant Field Values</a></dd>
</dl>
</li>
</ul>
</li>
</ul>
<!-- ============ METHOD DETAIL ========== -->
<ul class="blockList">
<li class="blockList"><a name="method.detail">
<!--   -->
</a>
<h3>Method Detail</h3>
<a name="getFSofPath-org.apache.hadoop.fs.Path-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>getFSofPath</h4>
<pre>protected&nbsp;<a href="../../../../org/apache/hadoop/fs/AbstractFileSystem.html" title="class in org.apache.hadoop.fs">AbstractFileSystem</a>&nbsp;getFSofPath(<a href="../../../../org/apache/hadoop/fs/Path.html" title="class in org.apache.hadoop.fs">Path</a>&nbsp;absOrFqPath)
                                  throws <a href="../../../../org/apache/hadoop/fs/UnsupportedFileSystemException.html" title="class in org.apache.hadoop.fs">UnsupportedFileSystemException</a>,
                                         <a href="https://docs.oracle.com/javase/8/docs/api/java/io/IOException.html?is-external=true" title="class or interface in java.io">IOException</a></pre>
<div class="block">Get the file system of supplied path.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>absOrFqPath</code> - - absolute or fully qualified path</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>the file system of the path</dd>
<dt><span class="throwsLabel">Throws:</span></dt>
<dd><code><a href="../../../../org/apache/hadoop/fs/UnsupportedFileSystemException.html" title="class in org.apache.hadoop.fs">UnsupportedFileSystemException</a></code> - If the file system for
           <code>absOrFqPath</code> is not supported.</dd>
<dd><code><a href="https://docs.oracle.com/javase/8/docs/api/java/io/IOException.html?is-external=true" title="class or interface in java.io">IOException</a></code> - If the file system for <code>absOrFqPath</code> could
         not be instantiated.</dd>
</dl>
</li>
</ul>
<a name="getFileContext-org.apache.hadoop.fs.AbstractFileSystem-org.apache.hadoop.conf.Configuration-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>getFileContext</h4>
<pre>public static&nbsp;<a href="../../../../org/apache/hadoop/fs/FileContext.html" title="class in org.apache.hadoop.fs">FileContext</a>&nbsp;getFileContext(<a href="../../../../org/apache/hadoop/fs/AbstractFileSystem.html" title="class in org.apache.hadoop.fs">AbstractFileSystem</a>&nbsp;defFS,
                                         <a href="../../../../org/apache/hadoop/conf/Configuration.html" title="class in org.apache.hadoop.conf">Configuration</a>&nbsp;aConf)</pre>
<div class="block">Create a FileContext with specified FS as default using the specified
 config.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>defFS</code> - </dd>
<dd><code>aConf</code> - </dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>new FileContext with specified FS as default.</dd>
</dl>
</li>
</ul>
<a name="getFileContext-org.apache.hadoop.fs.AbstractFileSystem-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>getFileContext</h4>
<pre>protected static&nbsp;<a href="../../../../org/apache/hadoop/fs/FileContext.html" title="class in org.apache.hadoop.fs">FileContext</a>&nbsp;getFileContext(<a href="../../../../org/apache/hadoop/fs/AbstractFileSystem.html" title="class in org.apache.hadoop.fs">AbstractFileSystem</a>&nbsp;defaultFS)</pre>
<div class="block">Create a FileContext for specified file system using the default config.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>defaultFS</code> - </dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>a FileContext with the specified AbstractFileSystem
                 as the default FS.</dd>
</dl>
</li>
</ul>
<a name="getFileContext--">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>getFileContext</h4>
<pre>public static&nbsp;<a href="../../../../org/apache/hadoop/fs/FileContext.html" title="class in org.apache.hadoop.fs">FileContext</a>&nbsp;getFileContext()
                                  throws <a href="../../../../org/apache/hadoop/fs/UnsupportedFileSystemException.html" title="class in org.apache.hadoop.fs">UnsupportedFileSystemException</a></pre>
<div class="block">Create a FileContext using the default config read from the
 $HADOOP_CONFIG/core.xml, Unspecified key-values for config are defaulted
 from core-defaults.xml in the release jar.</div>
<dl>
<dt><span class="throwsLabel">Throws:</span></dt>
<dd><code><a href="../../../../org/apache/hadoop/fs/UnsupportedFileSystemException.html" title="class in org.apache.hadoop.fs">UnsupportedFileSystemException</a></code> - If the file system from the default
           configuration is not supported</dd>
</dl>
</li>
</ul>
<a name="getLocalFSFileContext--">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>getLocalFSFileContext</h4>
<pre>public static&nbsp;<a href="../../../../org/apache/hadoop/fs/FileContext.html" title="class in org.apache.hadoop.fs">FileContext</a>&nbsp;getLocalFSFileContext()
                                         throws <a href="../../../../org/apache/hadoop/fs/UnsupportedFileSystemException.html" title="class in org.apache.hadoop.fs">UnsupportedFileSystemException</a></pre>
<dl>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>a FileContext for the local file system using the default config.</dd>
<dt><span class="throwsLabel">Throws:</span></dt>
<dd><code><a href="../../../../org/apache/hadoop/fs/UnsupportedFileSystemException.html" title="class in org.apache.hadoop.fs">UnsupportedFileSystemException</a></code> - If the file system for
           <a href="../../../../org/apache/hadoop/fs/FsConstants.html#LOCAL_FS_URI"><code>FsConstants.LOCAL_FS_URI</code></a> is not supported.</dd>
</dl>
</li>
</ul>
<a name="getFileContext-java.net.URI-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>getFileContext</h4>
<pre>public static&nbsp;<a href="../../../../org/apache/hadoop/fs/FileContext.html" title="class in org.apache.hadoop.fs">FileContext</a>&nbsp;getFileContext(<a href="https://docs.oracle.com/javase/8/docs/api/java/net/URI.html?is-external=true" title="class or interface in java.net">URI</a>&nbsp;defaultFsUri)
                                  throws <a href="../../../../org/apache/hadoop/fs/UnsupportedFileSystemException.html" title="class in org.apache.hadoop.fs">UnsupportedFileSystemException</a></pre>
<div class="block">Create a FileContext for specified URI using the default config.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>defaultFsUri</code> - </dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>a FileContext with the specified URI as the default FS.</dd>
<dt><span class="throwsLabel">Throws:</span></dt>
<dd><code><a href="../../../../org/apache/hadoop/fs/UnsupportedFileSystemException.html" title="class in org.apache.hadoop.fs">UnsupportedFileSystemException</a></code> - If the file system for
           <code>defaultFsUri</code> is not supported</dd>
</dl>
</li>
</ul>
<a name="getFileContext-java.net.URI-org.apache.hadoop.conf.Configuration-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>getFileContext</h4>
<pre>public static&nbsp;<a href="../../../../org/apache/hadoop/fs/FileContext.html" title="class in org.apache.hadoop.fs">FileContext</a>&nbsp;getFileContext(<a href="https://docs.oracle.com/javase/8/docs/api/java/net/URI.html?is-external=true" title="class or interface in java.net">URI</a>&nbsp;defaultFsUri,
                                         <a href="../../../../org/apache/hadoop/conf/Configuration.html" title="class in org.apache.hadoop.conf">Configuration</a>&nbsp;aConf)
                                  throws <a href="../../../../org/apache/hadoop/fs/UnsupportedFileSystemException.html" title="class in org.apache.hadoop.fs">UnsupportedFileSystemException</a></pre>
<div class="block">Create a FileContext for specified default URI using the specified config.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>defaultFsUri</code> - </dd>
<dd><code>aConf</code> - </dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>new FileContext for specified uri</dd>
<dt><span class="throwsLabel">Throws:</span></dt>
<dd><code><a href="../../../../org/apache/hadoop/fs/UnsupportedFileSystemException.html" title="class in org.apache.hadoop.fs">UnsupportedFileSystemException</a></code> - If the file system with specified is
           not supported</dd>
<dd><code><a href="https://docs.oracle.com/javase/8/docs/api/java/lang/RuntimeException.html?is-external=true" title="class or interface in java.lang">RuntimeException</a></code> - If the file system specified is supported but
         could not be instantiated, or if login fails.</dd>
</dl>
</li>
</ul>
<a name="getFileContext-org.apache.hadoop.conf.Configuration-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>getFileContext</h4>
<pre>public static&nbsp;<a href="../../../../org/apache/hadoop/fs/FileContext.html" title="class in org.apache.hadoop.fs">FileContext</a>&nbsp;getFileContext(<a href="../../../../org/apache/hadoop/conf/Configuration.html" title="class in org.apache.hadoop.conf">Configuration</a>&nbsp;aConf)
                                  throws <a href="../../../../org/apache/hadoop/fs/UnsupportedFileSystemException.html" title="class in org.apache.hadoop.fs">UnsupportedFileSystemException</a></pre>
<div class="block">Create a FileContext using the passed config. Generally it is better to use
 <a href="../../../../org/apache/hadoop/fs/FileContext.html#getFileContext-java.net.URI-org.apache.hadoop.conf.Configuration-"><code>getFileContext(URI, Configuration)</code></a> instead of this one.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>aConf</code> - </dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>new FileContext</dd>
<dt><span class="throwsLabel">Throws:</span></dt>
<dd><code><a href="../../../../org/apache/hadoop/fs/UnsupportedFileSystemException.html" title="class in org.apache.hadoop.fs">UnsupportedFileSystemException</a></code> - If file system in the config
           is not supported</dd>
</dl>
</li>
</ul>
<a name="getLocalFSFileContext-org.apache.hadoop.conf.Configuration-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>getLocalFSFileContext</h4>
<pre>public static&nbsp;<a href="../../../../org/apache/hadoop/fs/FileContext.html" title="class in org.apache.hadoop.fs">FileContext</a>&nbsp;getLocalFSFileContext(<a href="../../../../org/apache/hadoop/conf/Configuration.html" title="class in org.apache.hadoop.conf">Configuration</a>&nbsp;aConf)
                                         throws <a href="../../../../org/apache/hadoop/fs/UnsupportedFileSystemException.html" title="class in org.apache.hadoop.fs">UnsupportedFileSystemException</a></pre>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>aConf</code> - - from which the FileContext is configured</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>a FileContext for the local file system using the specified config.</dd>
<dt><span class="throwsLabel">Throws:</span></dt>
<dd><code><a href="../../../../org/apache/hadoop/fs/UnsupportedFileSystemException.html" title="class in org.apache.hadoop.fs">UnsupportedFileSystemException</a></code> - If default file system in the config
           is not supported</dd>
</dl>
</li>
</ul>
<a name="setWorkingDirectory-org.apache.hadoop.fs.Path-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>setWorkingDirectory</h4>
<pre>public&nbsp;void&nbsp;setWorkingDirectory(<a href="../../../../org/apache/hadoop/fs/Path.html" title="class in org.apache.hadoop.fs">Path</a>&nbsp;newWDir)
                         throws <a href="https://docs.oracle.com/javase/8/docs/api/java/io/IOException.html?is-external=true" title="class or interface in java.io">IOException</a></pre>
<div class="block">Set the working directory for wd-relative names (such a "foo/bar"). Working
 directory feature is provided by simply prefixing relative names with the
 working dir. Note this is different from Unix where the wd is actually set
 to the inode. Hence setWorkingDir does not follow symlinks etc. This works
 better in a distributed environment that has multiple independent roots.
 <a href="../../../../org/apache/hadoop/fs/FileContext.html#getWorkingDirectory--"><code>getWorkingDirectory()</code></a> should return what setWorkingDir() set.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>newWDir</code> - new working directory</dd>
<dt><span class="throwsLabel">Throws:</span></dt>
<dd><code><a href="https://docs.oracle.com/javase/8/docs/api/java/io/IOException.html?is-external=true" title="class or interface in java.io">IOException</a></code> - <br>
           NewWdir can be one of:
           <ul>
           <li>relative path: "foo/bar";</li>
           <li>absolute without scheme: "/foo/bar"</li>
           <li>fully qualified with scheme: "xx://auth/foo/bar"</li>
           </ul>
 <br>
           Illegal WDs:
           <ul>
           <li>relative with scheme: "xx:foo/bar"</li>
           <li>non existent directory</li>
           </ul></dd>
</dl>
</li>
</ul>
<a name="getWorkingDirectory--">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>getWorkingDirectory</h4>
<pre>public&nbsp;<a href="../../../../org/apache/hadoop/fs/Path.html" title="class in org.apache.hadoop.fs">Path</a>&nbsp;getWorkingDirectory()</pre>
<div class="block">Gets the working directory for wd-relative names (such a "foo/bar").</div>
</li>
</ul>
<a name="getUgi--">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>getUgi</h4>
<pre>public&nbsp;<a href="../../../../org/apache/hadoop/security/UserGroupInformation.html" title="class in org.apache.hadoop.security">UserGroupInformation</a>&nbsp;getUgi()</pre>
<div class="block">Gets the ugi in the file-context</div>
<dl>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>UserGroupInformation</dd>
</dl>
</li>
</ul>
<a name="getHomeDirectory--">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>getHomeDirectory</h4>
<pre>public&nbsp;<a href="../../../../org/apache/hadoop/fs/Path.html" title="class in org.apache.hadoop.fs">Path</a>&nbsp;getHomeDirectory()</pre>
<div class="block">Return the current user's home directory in this file system.
 The default implementation returns "/user/$USER/".</div>
<dl>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>the home directory</dd>
</dl>
</li>
</ul>
<a name="getUMask--">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>getUMask</h4>
<pre>public&nbsp;<a href="../../../../org/apache/hadoop/fs/permission/FsPermission.html" title="class in org.apache.hadoop.fs.permission">FsPermission</a>&nbsp;getUMask()</pre>
<dl>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>the umask of this FileContext</dd>
</dl>
</li>
</ul>
<a name="setUMask-org.apache.hadoop.fs.permission.FsPermission-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>setUMask</h4>
<pre>public&nbsp;void&nbsp;setUMask(<a href="../../../../org/apache/hadoop/fs/permission/FsPermission.html" title="class in org.apache.hadoop.fs.permission">FsPermission</a>&nbsp;newUmask)</pre>
<div class="block">Set umask to the supplied parameter.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>newUmask</code> - the new umask</dd>
</dl>
</li>
</ul>
<a name="resolvePath-org.apache.hadoop.fs.Path-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>resolvePath</h4>
<pre>public&nbsp;<a href="../../../../org/apache/hadoop/fs/Path.html" title="class in org.apache.hadoop.fs">Path</a>&nbsp;resolvePath(<a href="../../../../org/apache/hadoop/fs/Path.html" title="class in org.apache.hadoop.fs">Path</a>&nbsp;f)
                 throws <a href="https://docs.oracle.com/javase/8/docs/api/java/io/FileNotFoundException.html?is-external=true" title="class or interface in java.io">FileNotFoundException</a>,
                        org.apache.hadoop.fs.UnresolvedLinkException,
                        <a href="../../../../org/apache/hadoop/security/AccessControlException.html" title="class in org.apache.hadoop.security">AccessControlException</a>,
                        <a href="https://docs.oracle.com/javase/8/docs/api/java/io/IOException.html?is-external=true" title="class or interface in java.io">IOException</a></pre>
<div class="block">Resolve the path following any symlinks or mount points</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>f</code> - to be resolved</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>fully qualified resolved path</dd>
<dt><span class="throwsLabel">Throws:</span></dt>
<dd><code><a href="https://docs.oracle.com/javase/8/docs/api/java/io/FileNotFoundException.html?is-external=true" title="class or interface in java.io">FileNotFoundException</a></code> - If <code>f</code> does not exist</dd>
<dd><code><a href="../../../../org/apache/hadoop/security/AccessControlException.html" title="class in org.apache.hadoop.security">AccessControlException</a></code> - if access denied</dd>
<dd><code><a href="https://docs.oracle.com/javase/8/docs/api/java/io/IOException.html?is-external=true" title="class or interface in java.io">IOException</a></code> - If an IO Error occurred
 
 Exceptions applicable to file systems accessed over RPC:</dd>
<dd><code><a href="../../../../org/apache/hadoop/ipc/RpcClientException.html" title="class in org.apache.hadoop.ipc">RpcClientException</a></code> - If an exception occurred in the RPC client</dd>
<dd><code><a href="../../../../org/apache/hadoop/ipc/RpcServerException.html" title="class in org.apache.hadoop.ipc">RpcServerException</a></code> - If an exception occurred in the RPC server</dd>
<dd><code><a href="../../../../org/apache/hadoop/ipc/UnexpectedServerException.html" title="class in org.apache.hadoop.ipc">UnexpectedServerException</a></code> - If server implementation throws
           undeclared exception to RPC server
 
 RuntimeExceptions:</dd>
<dd><code><a href="../../../../org/apache/hadoop/fs/InvalidPathException.html" title="class in org.apache.hadoop.fs">InvalidPathException</a></code> - If path <code>f</code> is not valid</dd>
<dd><code>org.apache.hadoop.fs.UnresolvedLinkException</code></dd>
</dl>
</li>
</ul>
<a name="makeQualified-org.apache.hadoop.fs.Path-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>makeQualified</h4>
<pre>public&nbsp;<a href="../../../../org/apache/hadoop/fs/Path.html" title="class in org.apache.hadoop.fs">Path</a>&nbsp;makeQualified(<a href="../../../../org/apache/hadoop/fs/Path.html" title="class in org.apache.hadoop.fs">Path</a>&nbsp;path)</pre>
<div class="block">Make the path fully qualified if it is isn't. 
 A Fully-qualified path has scheme and authority specified and an absolute
 path.
 Use the default file system and working dir in this FileContext to qualify.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>path</code> - </dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>qualified path</dd>
</dl>
</li>
</ul>
<a name="create-org.apache.hadoop.fs.Path-java.util.EnumSet-org.apache.hadoop.fs.Options.CreateOpts...-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>create</h4>
<pre>public&nbsp;<a href="../../../../org/apache/hadoop/fs/FSDataOutputStream.html" title="class in org.apache.hadoop.fs">FSDataOutputStream</a>&nbsp;create(<a href="../../../../org/apache/hadoop/fs/Path.html" title="class in org.apache.hadoop.fs">Path</a>&nbsp;f,
                                 <a href="https://docs.oracle.com/javase/8/docs/api/java/util/EnumSet.html?is-external=true" title="class or interface in java.util">EnumSet</a>&lt;<a href="../../../../org/apache/hadoop/fs/CreateFlag.html" title="enum in org.apache.hadoop.fs">CreateFlag</a>&gt;&nbsp;createFlag,
                                 <a href="../../../../org/apache/hadoop/fs/Options.CreateOpts.html" title="class in org.apache.hadoop.fs">Options.CreateOpts</a>...&nbsp;opts)
                          throws <a href="../../../../org/apache/hadoop/security/AccessControlException.html" title="class in org.apache.hadoop.security">AccessControlException</a>,
                                 <a href="../../../../org/apache/hadoop/fs/FileAlreadyExistsException.html" title="class in org.apache.hadoop.fs">FileAlreadyExistsException</a>,
                                 <a href="https://docs.oracle.com/javase/8/docs/api/java/io/FileNotFoundException.html?is-external=true" title="class or interface in java.io">FileNotFoundException</a>,
                                 <a href="../../../../org/apache/hadoop/fs/ParentNotDirectoryException.html" title="class in org.apache.hadoop.fs">ParentNotDirectoryException</a>,
                                 <a href="../../../../org/apache/hadoop/fs/UnsupportedFileSystemException.html" title="class in org.apache.hadoop.fs">UnsupportedFileSystemException</a>,
                                 <a href="https://docs.oracle.com/javase/8/docs/api/java/io/IOException.html?is-external=true" title="class or interface in java.io">IOException</a></pre>
<div class="block">Create or overwrite file on indicated path and returns an output stream for
 writing into the file.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>f</code> - the file name to open</dd>
<dd><code>createFlag</code> - gives the semantics of create; see <a href="../../../../org/apache/hadoop/fs/CreateFlag.html" title="enum in org.apache.hadoop.fs"><code>CreateFlag</code></a></dd>
<dd><code>opts</code> - file creation options; see <a href="../../../../org/apache/hadoop/fs/Options.CreateOpts.html" title="class in org.apache.hadoop.fs"><code>Options.CreateOpts</code></a>.
          <ul>
          <li>Progress - to report progress on the operation - default null
          <li>Permission - umask is applied against permission: default is
          FsPermissions:getDefault()
 
          <li>CreateParent - create missing parent path; default is to not
          to create parents
          <li>The defaults for the following are SS defaults of the file
          server implementing the target path. Not all parameters make sense
          for all kinds of file system - eg. localFS ignores Blocksize,
          replication, checksum
          <ul>
          <li>BufferSize - buffersize used in FSDataOutputStream
          <li>Blocksize - block size for file blocks
          <li>ReplicationFactor - replication for blocks
          <li>ChecksumParam - Checksum parameters. server default is used
          if not specified.
          </ul>
          </ul></dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd><a href="../../../../org/apache/hadoop/fs/FSDataOutputStream.html" title="class in org.apache.hadoop.fs"><code>FSDataOutputStream</code></a> for created file</dd>
<dt><span class="throwsLabel">Throws:</span></dt>
<dd><code><a href="../../../../org/apache/hadoop/security/AccessControlException.html" title="class in org.apache.hadoop.security">AccessControlException</a></code> - If access is denied</dd>
<dd><code><a href="../../../../org/apache/hadoop/fs/FileAlreadyExistsException.html" title="class in org.apache.hadoop.fs">FileAlreadyExistsException</a></code> - If file <code>f</code> already exists</dd>
<dd><code><a href="https://docs.oracle.com/javase/8/docs/api/java/io/FileNotFoundException.html?is-external=true" title="class or interface in java.io">FileNotFoundException</a></code> - If parent of <code>f</code> does not exist
           and <code>createParent</code> is false</dd>
<dd><code><a href="../../../../org/apache/hadoop/fs/ParentNotDirectoryException.html" title="class in org.apache.hadoop.fs">ParentNotDirectoryException</a></code> - If parent of <code>f</code> is not a
           directory.</dd>
<dd><code><a href="../../../../org/apache/hadoop/fs/UnsupportedFileSystemException.html" title="class in org.apache.hadoop.fs">UnsupportedFileSystemException</a></code> - If file system for <code>f</code> is
           not supported</dd>
<dd><code><a href="https://docs.oracle.com/javase/8/docs/api/java/io/IOException.html?is-external=true" title="class or interface in java.io">IOException</a></code> - If an I/O error occurred
 
 Exceptions applicable to file systems accessed over RPC:</dd>
<dd><code><a href="../../../../org/apache/hadoop/ipc/RpcClientException.html" title="class in org.apache.hadoop.ipc">RpcClientException</a></code> - If an exception occurred in the RPC client</dd>
<dd><code><a href="../../../../org/apache/hadoop/ipc/RpcServerException.html" title="class in org.apache.hadoop.ipc">RpcServerException</a></code> - If an exception occurred in the RPC server</dd>
<dd><code><a href="../../../../org/apache/hadoop/ipc/UnexpectedServerException.html" title="class in org.apache.hadoop.ipc">UnexpectedServerException</a></code> - If server implementation throws
           undeclared exception to RPC server
 
 RuntimeExceptions:</dd>
<dd><code><a href="../../../../org/apache/hadoop/fs/InvalidPathException.html" title="class in org.apache.hadoop.fs">InvalidPathException</a></code> - If path <code>f</code> is not valid</dd>
</dl>
</li>
</ul>
<a name="create-org.apache.hadoop.fs.Path-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>create</h4>
<pre>public&nbsp;<a href="../../../../org/apache/hadoop/fs/FSDataOutputStreamBuilder.html" title="class in org.apache.hadoop.fs">FSDataOutputStreamBuilder</a>&lt;<a href="../../../../org/apache/hadoop/fs/FSDataOutputStream.html" title="class in org.apache.hadoop.fs">FSDataOutputStream</a>,?&gt;&nbsp;create(<a href="../../../../org/apache/hadoop/fs/Path.html" title="class in org.apache.hadoop.fs">Path</a>&nbsp;f)
                                                       throws <a href="https://docs.oracle.com/javase/8/docs/api/java/io/IOException.html?is-external=true" title="class or interface in java.io">IOException</a></pre>
<div class="block">Create a <a href="../../../../org/apache/hadoop/fs/FSDataOutputStreamBuilder.html" title="class in org.apache.hadoop.fs"><code>FSDataOutputStreamBuilder</code></a> for creating or overwriting
 a file on indicated path.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>f</code> - the file path to create builder for.</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd><a href="../../../../org/apache/hadoop/fs/FSDataOutputStreamBuilder.html" title="class in org.apache.hadoop.fs"><code>FSDataOutputStreamBuilder</code></a> to build a
         <a href="../../../../org/apache/hadoop/fs/FSDataOutputStream.html" title="class in org.apache.hadoop.fs"><code>FSDataOutputStream</code></a>.

 Upon <a href="../../../../org/apache/hadoop/fs/FSDataOutputStreamBuilder.html#build--"><code>FSDataOutputStreamBuilder.build()</code></a> being invoked,
 builder parameters will be verified by <a href="../../../../org/apache/hadoop/fs/FileContext.html" title="class in org.apache.hadoop.fs"><code>FileContext</code></a> and
 <a href="../../../../org/apache/hadoop/fs/AbstractFileSystem.html#create-org.apache.hadoop.fs.Path-java.util.EnumSet-org.apache.hadoop.fs.Options.CreateOpts...-"><code>AbstractFileSystem.create(org.apache.hadoop.fs.Path, java.util.EnumSet&lt;org.apache.hadoop.fs.CreateFlag&gt;, org.apache.hadoop.fs.Options.CreateOpts...)</code></a>. And filesystem states will be modified.

 Client should expect <a href="../../../../org/apache/hadoop/fs/FSDataOutputStreamBuilder.html#build--"><code>FSDataOutputStreamBuilder.build()</code></a> throw the
 same exceptions as create(Path, EnumSet, CreateOpts...).</dd>
<dt><span class="throwsLabel">Throws:</span></dt>
<dd><code><a href="https://docs.oracle.com/javase/8/docs/api/java/io/IOException.html?is-external=true" title="class or interface in java.io">IOException</a></code></dd>
</dl>
</li>
</ul>
<a name="mkdir-org.apache.hadoop.fs.Path-org.apache.hadoop.fs.permission.FsPermission-boolean-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>mkdir</h4>
<pre>public&nbsp;void&nbsp;mkdir(<a href="../../../../org/apache/hadoop/fs/Path.html" title="class in org.apache.hadoop.fs">Path</a>&nbsp;dir,
                  <a href="../../../../org/apache/hadoop/fs/permission/FsPermission.html" title="class in org.apache.hadoop.fs.permission">FsPermission</a>&nbsp;permission,
                  boolean&nbsp;createParent)
           throws <a href="../../../../org/apache/hadoop/security/AccessControlException.html" title="class in org.apache.hadoop.security">AccessControlException</a>,
                  <a href="../../../../org/apache/hadoop/fs/FileAlreadyExistsException.html" title="class in org.apache.hadoop.fs">FileAlreadyExistsException</a>,
                  <a href="https://docs.oracle.com/javase/8/docs/api/java/io/FileNotFoundException.html?is-external=true" title="class or interface in java.io">FileNotFoundException</a>,
                  <a href="../../../../org/apache/hadoop/fs/ParentNotDirectoryException.html" title="class in org.apache.hadoop.fs">ParentNotDirectoryException</a>,
                  <a href="../../../../org/apache/hadoop/fs/UnsupportedFileSystemException.html" title="class in org.apache.hadoop.fs">UnsupportedFileSystemException</a>,
                  <a href="https://docs.oracle.com/javase/8/docs/api/java/io/IOException.html?is-external=true" title="class or interface in java.io">IOException</a></pre>
<div class="block">Make(create) a directory and all the non-existent parents.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>dir</code> - - the dir to make</dd>
<dd><code>permission</code> - - permissions is set permission&amp;~umask</dd>
<dd><code>createParent</code> - - if true then missing parent dirs are created if false
          then parent must exist</dd>
<dt><span class="throwsLabel">Throws:</span></dt>
<dd><code><a href="../../../../org/apache/hadoop/security/AccessControlException.html" title="class in org.apache.hadoop.security">AccessControlException</a></code> - If access is denied</dd>
<dd><code><a href="../../../../org/apache/hadoop/fs/FileAlreadyExistsException.html" title="class in org.apache.hadoop.fs">FileAlreadyExistsException</a></code> - If directory <code>dir</code> already
           exists</dd>
<dd><code><a href="https://docs.oracle.com/javase/8/docs/api/java/io/FileNotFoundException.html?is-external=true" title="class or interface in java.io">FileNotFoundException</a></code> - If parent of <code>dir</code> does not exist
           and <code>createParent</code> is false</dd>
<dd><code><a href="../../../../org/apache/hadoop/fs/ParentNotDirectoryException.html" title="class in org.apache.hadoop.fs">ParentNotDirectoryException</a></code> - If parent of <code>dir</code> is not a
           directory</dd>
<dd><code><a href="../../../../org/apache/hadoop/fs/UnsupportedFileSystemException.html" title="class in org.apache.hadoop.fs">UnsupportedFileSystemException</a></code> - If file system for <code>dir</code>
         is not supported</dd>
<dd><code><a href="https://docs.oracle.com/javase/8/docs/api/java/io/IOException.html?is-external=true" title="class or interface in java.io">IOException</a></code> - If an I/O error occurred
 
 Exceptions applicable to file systems accessed over RPC:</dd>
<dd><code><a href="../../../../org/apache/hadoop/ipc/RpcClientException.html" title="class in org.apache.hadoop.ipc">RpcClientException</a></code> - If an exception occurred in the RPC client</dd>
<dd><code><a href="../../../../org/apache/hadoop/ipc/UnexpectedServerException.html" title="class in org.apache.hadoop.ipc">UnexpectedServerException</a></code> - If server implementation throws 
           undeclared exception to RPC server
 
 RuntimeExceptions:</dd>
<dd><code><a href="../../../../org/apache/hadoop/fs/InvalidPathException.html" title="class in org.apache.hadoop.fs">InvalidPathException</a></code> - If path <code>dir</code> is not valid</dd>
</dl>
</li>
</ul>
<a name="delete-org.apache.hadoop.fs.Path-boolean-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>delete</h4>
<pre>public&nbsp;boolean&nbsp;delete(<a href="../../../../org/apache/hadoop/fs/Path.html" title="class in org.apache.hadoop.fs">Path</a>&nbsp;f,
                      boolean&nbsp;recursive)
               throws <a href="../../../../org/apache/hadoop/security/AccessControlException.html" title="class in org.apache.hadoop.security">AccessControlException</a>,
                      <a href="https://docs.oracle.com/javase/8/docs/api/java/io/FileNotFoundException.html?is-external=true" title="class or interface in java.io">FileNotFoundException</a>,
                      <a href="../../../../org/apache/hadoop/fs/UnsupportedFileSystemException.html" title="class in org.apache.hadoop.fs">UnsupportedFileSystemException</a>,
                      <a href="https://docs.oracle.com/javase/8/docs/api/java/io/IOException.html?is-external=true" title="class or interface in java.io">IOException</a></pre>
<div class="block">Delete a file.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>f</code> - the path to delete.</dd>
<dd><code>recursive</code> - if path is a directory and set to 
 true, the directory is deleted else throws an exception. In
 case of a file the recursive can be set to either true or false.</dd>
<dt><span class="throwsLabel">Throws:</span></dt>
<dd><code><a href="../../../../org/apache/hadoop/security/AccessControlException.html" title="class in org.apache.hadoop.security">AccessControlException</a></code> - If access is denied</dd>
<dd><code><a href="https://docs.oracle.com/javase/8/docs/api/java/io/FileNotFoundException.html?is-external=true" title="class or interface in java.io">FileNotFoundException</a></code> - If <code>f</code> does not exist</dd>
<dd><code><a href="../../../../org/apache/hadoop/fs/UnsupportedFileSystemException.html" title="class in org.apache.hadoop.fs">UnsupportedFileSystemException</a></code> - If file system for <code>f</code> is
           not supported</dd>
<dd><code><a href="https://docs.oracle.com/javase/8/docs/api/java/io/IOException.html?is-external=true" title="class or interface in java.io">IOException</a></code> - If an I/O error occurred
 
 Exceptions applicable to file systems accessed over RPC:</dd>
<dd><code><a href="../../../../org/apache/hadoop/ipc/RpcClientException.html" title="class in org.apache.hadoop.ipc">RpcClientException</a></code> - If an exception occurred in the RPC client</dd>
<dd><code><a href="../../../../org/apache/hadoop/ipc/RpcServerException.html" title="class in org.apache.hadoop.ipc">RpcServerException</a></code> - If an exception occurred in the RPC server</dd>
<dd><code><a href="../../../../org/apache/hadoop/ipc/UnexpectedServerException.html" title="class in org.apache.hadoop.ipc">UnexpectedServerException</a></code> - If server implementation throws 
           undeclared exception to RPC server
 
 RuntimeExceptions:</dd>
<dd><code><a href="../../../../org/apache/hadoop/fs/InvalidPathException.html" title="class in org.apache.hadoop.fs">InvalidPathException</a></code> - If path <code>f</code> is invalid</dd>
</dl>
</li>
</ul>
<a name="open-org.apache.hadoop.fs.Path-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>open</h4>
<pre>public&nbsp;<a href="../../../../org/apache/hadoop/fs/FSDataInputStream.html" title="class in org.apache.hadoop.fs">FSDataInputStream</a>&nbsp;open(<a href="../../../../org/apache/hadoop/fs/Path.html" title="class in org.apache.hadoop.fs">Path</a>&nbsp;f)
                       throws <a href="../../../../org/apache/hadoop/security/AccessControlException.html" title="class in org.apache.hadoop.security">AccessControlException</a>,
                              <a href="https://docs.oracle.com/javase/8/docs/api/java/io/FileNotFoundException.html?is-external=true" title="class or interface in java.io">FileNotFoundException</a>,
                              <a href="../../../../org/apache/hadoop/fs/UnsupportedFileSystemException.html" title="class in org.apache.hadoop.fs">UnsupportedFileSystemException</a>,
                              <a href="https://docs.oracle.com/javase/8/docs/api/java/io/IOException.html?is-external=true" title="class or interface in java.io">IOException</a></pre>
<div class="block">Opens an FSDataInputStream at the indicated Path using
 default buffersize.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>f</code> - the file name to open</dd>
<dt><span class="throwsLabel">Throws:</span></dt>
<dd><code><a href="../../../../org/apache/hadoop/security/AccessControlException.html" title="class in org.apache.hadoop.security">AccessControlException</a></code> - If access is denied</dd>
<dd><code><a href="https://docs.oracle.com/javase/8/docs/api/java/io/FileNotFoundException.html?is-external=true" title="class or interface in java.io">FileNotFoundException</a></code> - If file <code>f</code> does not exist</dd>
<dd><code><a href="../../../../org/apache/hadoop/fs/UnsupportedFileSystemException.html" title="class in org.apache.hadoop.fs">UnsupportedFileSystemException</a></code> - If file system for <code>f</code>
         is not supported</dd>
<dd><code><a href="https://docs.oracle.com/javase/8/docs/api/java/io/IOException.html?is-external=true" title="class or interface in java.io">IOException</a></code> - If an I/O error occurred
 
 Exceptions applicable to file systems accessed over RPC:</dd>
<dd><code><a href="../../../../org/apache/hadoop/ipc/RpcClientException.html" title="class in org.apache.hadoop.ipc">RpcClientException</a></code> - If an exception occurred in the RPC client</dd>
<dd><code><a href="../../../../org/apache/hadoop/ipc/RpcServerException.html" title="class in org.apache.hadoop.ipc">RpcServerException</a></code> - If an exception occurred in the RPC server</dd>
<dd><code><a href="../../../../org/apache/hadoop/ipc/UnexpectedServerException.html" title="class in org.apache.hadoop.ipc">UnexpectedServerException</a></code> - If server implementation throws 
           undeclared exception to RPC server</dd>
</dl>
</li>
</ul>
<a name="open-org.apache.hadoop.fs.Path-int-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>open</h4>
<pre>public&nbsp;<a href="../../../../org/apache/hadoop/fs/FSDataInputStream.html" title="class in org.apache.hadoop.fs">FSDataInputStream</a>&nbsp;open(<a href="../../../../org/apache/hadoop/fs/Path.html" title="class in org.apache.hadoop.fs">Path</a>&nbsp;f,
                              int&nbsp;bufferSize)
                       throws <a href="../../../../org/apache/hadoop/security/AccessControlException.html" title="class in org.apache.hadoop.security">AccessControlException</a>,
                              <a href="https://docs.oracle.com/javase/8/docs/api/java/io/FileNotFoundException.html?is-external=true" title="class or interface in java.io">FileNotFoundException</a>,
                              <a href="../../../../org/apache/hadoop/fs/UnsupportedFileSystemException.html" title="class in org.apache.hadoop.fs">UnsupportedFileSystemException</a>,
                              <a href="https://docs.oracle.com/javase/8/docs/api/java/io/IOException.html?is-external=true" title="class or interface in java.io">IOException</a></pre>
<div class="block">Opens an FSDataInputStream at the indicated Path.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>f</code> - the file name to open</dd>
<dd><code>bufferSize</code> - the size of the buffer to be used.</dd>
<dt><span class="throwsLabel">Throws:</span></dt>
<dd><code><a href="../../../../org/apache/hadoop/security/AccessControlException.html" title="class in org.apache.hadoop.security">AccessControlException</a></code> - If access is denied</dd>
<dd><code><a href="https://docs.oracle.com/javase/8/docs/api/java/io/FileNotFoundException.html?is-external=true" title="class or interface in java.io">FileNotFoundException</a></code> - If file <code>f</code> does not exist</dd>
<dd><code><a href="../../../../org/apache/hadoop/fs/UnsupportedFileSystemException.html" title="class in org.apache.hadoop.fs">UnsupportedFileSystemException</a></code> - If file system for <code>f</code> is
           not supported</dd>
<dd><code><a href="https://docs.oracle.com/javase/8/docs/api/java/io/IOException.html?is-external=true" title="class or interface in java.io">IOException</a></code> - If an I/O error occurred
 
 Exceptions applicable to file systems accessed over RPC:</dd>
<dd><code><a href="../../../../org/apache/hadoop/ipc/RpcClientException.html" title="class in org.apache.hadoop.ipc">RpcClientException</a></code> - If an exception occurred in the RPC client</dd>
<dd><code><a href="../../../../org/apache/hadoop/ipc/RpcServerException.html" title="class in org.apache.hadoop.ipc">RpcServerException</a></code> - If an exception occurred in the RPC server</dd>
<dd><code><a href="../../../../org/apache/hadoop/ipc/UnexpectedServerException.html" title="class in org.apache.hadoop.ipc">UnexpectedServerException</a></code> - If server implementation throws 
           undeclared exception to RPC server</dd>
</dl>
</li>
</ul>
<a name="truncate-org.apache.hadoop.fs.Path-long-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>truncate</h4>
<pre>public&nbsp;boolean&nbsp;truncate(<a href="../../../../org/apache/hadoop/fs/Path.html" title="class in org.apache.hadoop.fs">Path</a>&nbsp;f,
                        long&nbsp;newLength)
                 throws <a href="../../../../org/apache/hadoop/security/AccessControlException.html" title="class in org.apache.hadoop.security">AccessControlException</a>,
                        <a href="https://docs.oracle.com/javase/8/docs/api/java/io/FileNotFoundException.html?is-external=true" title="class or interface in java.io">FileNotFoundException</a>,
                        <a href="../../../../org/apache/hadoop/fs/UnsupportedFileSystemException.html" title="class in org.apache.hadoop.fs">UnsupportedFileSystemException</a>,
                        <a href="https://docs.oracle.com/javase/8/docs/api/java/io/IOException.html?is-external=true" title="class or interface in java.io">IOException</a></pre>
<div class="block">Truncate the file in the indicated path to the indicated size.
 <ul>
 <li>Fails if path is a directory.
 <li>Fails if path does not exist.
 <li>Fails if path is not closed.
 <li>Fails if new size is greater than current size.
 </ul></div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>f</code> - The path to the file to be truncated</dd>
<dd><code>newLength</code> - The size the file is to be truncated to</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd><code>true</code> if the file has been truncated to the desired
 <code>newLength</code> and is immediately available to be reused for
 write operations such as <code>append</code>, or
 <code>false</code> if a background process of adjusting the length of
 the last block has been started, and clients should wait for it to
 complete before proceeding with further file updates.</dd>
<dt><span class="throwsLabel">Throws:</span></dt>
<dd><code><a href="../../../../org/apache/hadoop/security/AccessControlException.html" title="class in org.apache.hadoop.security">AccessControlException</a></code> - If access is denied</dd>
<dd><code><a href="https://docs.oracle.com/javase/8/docs/api/java/io/FileNotFoundException.html?is-external=true" title="class or interface in java.io">FileNotFoundException</a></code> - If file <code>f</code> does not exist</dd>
<dd><code><a href="../../../../org/apache/hadoop/fs/UnsupportedFileSystemException.html" title="class in org.apache.hadoop.fs">UnsupportedFileSystemException</a></code> - If file system for <code>f</code> is
           not supported</dd>
<dd><code><a href="https://docs.oracle.com/javase/8/docs/api/java/io/IOException.html?is-external=true" title="class or interface in java.io">IOException</a></code> - If an I/O error occurred

 Exceptions applicable to file systems accessed over RPC:</dd>
<dd><code><a href="../../../../org/apache/hadoop/ipc/RpcClientException.html" title="class in org.apache.hadoop.ipc">RpcClientException</a></code> - If an exception occurred in the RPC client</dd>
<dd><code><a href="../../../../org/apache/hadoop/ipc/RpcServerException.html" title="class in org.apache.hadoop.ipc">RpcServerException</a></code> - If an exception occurred in the RPC server</dd>
<dd><code><a href="../../../../org/apache/hadoop/ipc/UnexpectedServerException.html" title="class in org.apache.hadoop.ipc">UnexpectedServerException</a></code> - If server implementation throws
           undeclared exception to RPC server</dd>
</dl>
</li>
</ul>
<a name="setReplication-org.apache.hadoop.fs.Path-short-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>setReplication</h4>
<pre>public&nbsp;boolean&nbsp;setReplication(<a href="../../../../org/apache/hadoop/fs/Path.html" title="class in org.apache.hadoop.fs">Path</a>&nbsp;f,
                              short&nbsp;replication)
                       throws <a href="../../../../org/apache/hadoop/security/AccessControlException.html" title="class in org.apache.hadoop.security">AccessControlException</a>,
                              <a href="https://docs.oracle.com/javase/8/docs/api/java/io/FileNotFoundException.html?is-external=true" title="class or interface in java.io">FileNotFoundException</a>,
                              <a href="https://docs.oracle.com/javase/8/docs/api/java/io/IOException.html?is-external=true" title="class or interface in java.io">IOException</a></pre>
<div class="block">Set replication for an existing file.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>f</code> - file name</dd>
<dd><code>replication</code> - new replication</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>true if successful</dd>
<dt><span class="throwsLabel">Throws:</span></dt>
<dd><code><a href="../../../../org/apache/hadoop/security/AccessControlException.html" title="class in org.apache.hadoop.security">AccessControlException</a></code> - If access is denied</dd>
<dd><code><a href="https://docs.oracle.com/javase/8/docs/api/java/io/FileNotFoundException.html?is-external=true" title="class or interface in java.io">FileNotFoundException</a></code> - If file <code>f</code> does not exist</dd>
<dd><code><a href="https://docs.oracle.com/javase/8/docs/api/java/io/IOException.html?is-external=true" title="class or interface in java.io">IOException</a></code> - If an I/O error occurred
 
 Exceptions applicable to file systems accessed over RPC:</dd>
<dd><code><a href="../../../../org/apache/hadoop/ipc/RpcClientException.html" title="class in org.apache.hadoop.ipc">RpcClientException</a></code> - If an exception occurred in the RPC client</dd>
<dd><code><a href="../../../../org/apache/hadoop/ipc/RpcServerException.html" title="class in org.apache.hadoop.ipc">RpcServerException</a></code> - If an exception occurred in the RPC server</dd>
<dd><code><a href="../../../../org/apache/hadoop/ipc/UnexpectedServerException.html" title="class in org.apache.hadoop.ipc">UnexpectedServerException</a></code> - If server implementation throws 
           undeclared exception to RPC server</dd>
</dl>
</li>
</ul>
<a name="rename-org.apache.hadoop.fs.Path-org.apache.hadoop.fs.Path-org.apache.hadoop.fs.Options.Rename...-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>rename</h4>
<pre>public&nbsp;void&nbsp;rename(<a href="../../../../org/apache/hadoop/fs/Path.html" title="class in org.apache.hadoop.fs">Path</a>&nbsp;src,
                   <a href="../../../../org/apache/hadoop/fs/Path.html" title="class in org.apache.hadoop.fs">Path</a>&nbsp;dst,
                   <a href="../../../../org/apache/hadoop/fs/Options.Rename.html" title="enum in org.apache.hadoop.fs">Options.Rename</a>...&nbsp;options)
            throws <a href="../../../../org/apache/hadoop/security/AccessControlException.html" title="class in org.apache.hadoop.security">AccessControlException</a>,
                   <a href="../../../../org/apache/hadoop/fs/FileAlreadyExistsException.html" title="class in org.apache.hadoop.fs">FileAlreadyExistsException</a>,
                   <a href="https://docs.oracle.com/javase/8/docs/api/java/io/FileNotFoundException.html?is-external=true" title="class or interface in java.io">FileNotFoundException</a>,
                   <a href="../../../../org/apache/hadoop/fs/ParentNotDirectoryException.html" title="class in org.apache.hadoop.fs">ParentNotDirectoryException</a>,
                   <a href="../../../../org/apache/hadoop/fs/UnsupportedFileSystemException.html" title="class in org.apache.hadoop.fs">UnsupportedFileSystemException</a>,
                   <a href="https://docs.oracle.com/javase/8/docs/api/java/io/IOException.html?is-external=true" title="class or interface in java.io">IOException</a></pre>
<div class="block">Renames Path src to Path dst
 <ul>
 <li>Fails if src is a file and dst is a directory.
 <li>Fails if src is a directory and dst is a file.
 <li>Fails if the parent of dst does not exist or is a file.
 </ul>
 <p>
 If OVERWRITE option is not passed as an argument, rename fails if the dst
 already exists.
 <p>
 If OVERWRITE option is passed as an argument, rename overwrites the dst if
 it is a file or an empty directory. Rename fails if dst is a non-empty
 directory.
 <p>
 Note that atomicity of rename is dependent on the file system
 implementation. Please refer to the file system documentation for details
 <p></div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>src</code> - path to be renamed</dd>
<dd><code>dst</code> - new path after rename</dd>
<dt><span class="throwsLabel">Throws:</span></dt>
<dd><code><a href="../../../../org/apache/hadoop/security/AccessControlException.html" title="class in org.apache.hadoop.security">AccessControlException</a></code> - If access is denied</dd>
<dd><code><a href="../../../../org/apache/hadoop/fs/FileAlreadyExistsException.html" title="class in org.apache.hadoop.fs">FileAlreadyExistsException</a></code> - If <code>dst</code> already exists and
           <code>options</code> has <a href="../../../../org/apache/hadoop/fs/Options.Rename.html#OVERWRITE"><code>Options.Rename.OVERWRITE</code></a>
           option false.</dd>
<dd><code><a href="https://docs.oracle.com/javase/8/docs/api/java/io/FileNotFoundException.html?is-external=true" title="class or interface in java.io">FileNotFoundException</a></code> - If <code>src</code> does not exist</dd>
<dd><code><a href="../../../../org/apache/hadoop/fs/ParentNotDirectoryException.html" title="class in org.apache.hadoop.fs">ParentNotDirectoryException</a></code> - If parent of <code>dst</code> is not a
           directory</dd>
<dd><code><a href="../../../../org/apache/hadoop/fs/UnsupportedFileSystemException.html" title="class in org.apache.hadoop.fs">UnsupportedFileSystemException</a></code> - If file system for <code>src</code>
           and <code>dst</code> is not supported</dd>
<dd><code><a href="https://docs.oracle.com/javase/8/docs/api/java/io/IOException.html?is-external=true" title="class or interface in java.io">IOException</a></code> - If an I/O error occurred
 
 Exceptions applicable to file systems accessed over RPC:</dd>
<dd><code><a href="../../../../org/apache/hadoop/ipc/RpcClientException.html" title="class in org.apache.hadoop.ipc">RpcClientException</a></code> - If an exception occurred in the RPC client</dd>
<dd><code><a href="../../../../org/apache/hadoop/ipc/RpcServerException.html" title="class in org.apache.hadoop.ipc">RpcServerException</a></code> - If an exception occurred in the RPC server</dd>
<dd><code><a href="../../../../org/apache/hadoop/ipc/UnexpectedServerException.html" title="class in org.apache.hadoop.ipc">UnexpectedServerException</a></code> - If server implementation throws
           undeclared exception to RPC server</dd>
</dl>
</li>
</ul>
<a name="setPermission-org.apache.hadoop.fs.Path-org.apache.hadoop.fs.permission.FsPermission-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>setPermission</h4>
<pre>public&nbsp;void&nbsp;setPermission(<a href="../../../../org/apache/hadoop/fs/Path.html" title="class in org.apache.hadoop.fs">Path</a>&nbsp;f,
                          <a href="../../../../org/apache/hadoop/fs/permission/FsPermission.html" title="class in org.apache.hadoop.fs.permission">FsPermission</a>&nbsp;permission)
                   throws <a href="../../../../org/apache/hadoop/security/AccessControlException.html" title="class in org.apache.hadoop.security">AccessControlException</a>,
                          <a href="https://docs.oracle.com/javase/8/docs/api/java/io/FileNotFoundException.html?is-external=true" title="class or interface in java.io">FileNotFoundException</a>,
                          <a href="../../../../org/apache/hadoop/fs/UnsupportedFileSystemException.html" title="class in org.apache.hadoop.fs">UnsupportedFileSystemException</a>,
                          <a href="https://docs.oracle.com/javase/8/docs/api/java/io/IOException.html?is-external=true" title="class or interface in java.io">IOException</a></pre>
<div class="block">Set permission of a path.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>f</code> - </dd>
<dd><code>permission</code> - - the new absolute permission (umask is not applied)</dd>
<dt><span class="throwsLabel">Throws:</span></dt>
<dd><code><a href="../../../../org/apache/hadoop/security/AccessControlException.html" title="class in org.apache.hadoop.security">AccessControlException</a></code> - If access is denied</dd>
<dd><code><a href="https://docs.oracle.com/javase/8/docs/api/java/io/FileNotFoundException.html?is-external=true" title="class or interface in java.io">FileNotFoundException</a></code> - If <code>f</code> does not exist</dd>
<dd><code><a href="../../../../org/apache/hadoop/fs/UnsupportedFileSystemException.html" title="class in org.apache.hadoop.fs">UnsupportedFileSystemException</a></code> - If file system for <code>f</code>
         is not supported</dd>
<dd><code><a href="https://docs.oracle.com/javase/8/docs/api/java/io/IOException.html?is-external=true" title="class or interface in java.io">IOException</a></code> - If an I/O error occurred
 
 Exceptions applicable to file systems accessed over RPC:</dd>
<dd><code><a href="../../../../org/apache/hadoop/ipc/RpcClientException.html" title="class in org.apache.hadoop.ipc">RpcClientException</a></code> - If an exception occurred in the RPC client</dd>
<dd><code><a href="../../../../org/apache/hadoop/ipc/RpcServerException.html" title="class in org.apache.hadoop.ipc">RpcServerException</a></code> - If an exception occurred in the RPC server</dd>
<dd><code><a href="../../../../org/apache/hadoop/ipc/UnexpectedServerException.html" title="class in org.apache.hadoop.ipc">UnexpectedServerException</a></code> - If server implementation throws 
           undeclared exception to RPC server</dd>
</dl>
</li>
</ul>
<a name="setOwner-org.apache.hadoop.fs.Path-java.lang.String-java.lang.String-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>setOwner</h4>
<pre>public&nbsp;void&nbsp;setOwner(<a href="../../../../org/apache/hadoop/fs/Path.html" title="class in org.apache.hadoop.fs">Path</a>&nbsp;f,
                     <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&nbsp;username,
                     <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&nbsp;groupname)
              throws <a href="../../../../org/apache/hadoop/security/AccessControlException.html" title="class in org.apache.hadoop.security">AccessControlException</a>,
                     <a href="../../../../org/apache/hadoop/fs/UnsupportedFileSystemException.html" title="class in org.apache.hadoop.fs">UnsupportedFileSystemException</a>,
                     <a href="https://docs.oracle.com/javase/8/docs/api/java/io/FileNotFoundException.html?is-external=true" title="class or interface in java.io">FileNotFoundException</a>,
                     <a href="https://docs.oracle.com/javase/8/docs/api/java/io/IOException.html?is-external=true" title="class or interface in java.io">IOException</a></pre>
<div class="block">Set owner of a path (i.e. a file or a directory). The parameters username
 and groupname cannot both be null.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>f</code> - The path</dd>
<dd><code>username</code> - If it is null, the original username remains unchanged.</dd>
<dd><code>groupname</code> - If it is null, the original groupname remains unchanged.</dd>
<dt><span class="throwsLabel">Throws:</span></dt>
<dd><code><a href="../../../../org/apache/hadoop/security/AccessControlException.html" title="class in org.apache.hadoop.security">AccessControlException</a></code> - If access is denied</dd>
<dd><code><a href="https://docs.oracle.com/javase/8/docs/api/java/io/FileNotFoundException.html?is-external=true" title="class or interface in java.io">FileNotFoundException</a></code> - If <code>f</code> does not exist</dd>
<dd><code><a href="../../../../org/apache/hadoop/fs/UnsupportedFileSystemException.html" title="class in org.apache.hadoop.fs">UnsupportedFileSystemException</a></code> - If file system for <code>f</code> is
           not supported</dd>
<dd><code><a href="https://docs.oracle.com/javase/8/docs/api/java/io/IOException.html?is-external=true" title="class or interface in java.io">IOException</a></code> - If an I/O error occurred
 
 Exceptions applicable to file systems accessed over RPC:</dd>
<dd><code><a href="../../../../org/apache/hadoop/ipc/RpcClientException.html" title="class in org.apache.hadoop.ipc">RpcClientException</a></code> - If an exception occurred in the RPC client</dd>
<dd><code><a href="../../../../org/apache/hadoop/ipc/RpcServerException.html" title="class in org.apache.hadoop.ipc">RpcServerException</a></code> - If an exception occurred in the RPC server</dd>
<dd><code><a href="../../../../org/apache/hadoop/ipc/UnexpectedServerException.html" title="class in org.apache.hadoop.ipc">UnexpectedServerException</a></code> - If server implementation throws 
           undeclared exception to RPC server
 
 RuntimeExceptions:</dd>
<dd><code><a href="../../../../org/apache/hadoop/HadoopIllegalArgumentException.html" title="class in org.apache.hadoop">HadoopIllegalArgumentException</a></code> - If <code>username</code> or
           <code>groupname</code> is invalid.</dd>
</dl>
</li>
</ul>
<a name="setTimes-org.apache.hadoop.fs.Path-long-long-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>setTimes</h4>
<pre>public&nbsp;void&nbsp;setTimes(<a href="../../../../org/apache/hadoop/fs/Path.html" title="class in org.apache.hadoop.fs">Path</a>&nbsp;f,
                     long&nbsp;mtime,
                     long&nbsp;atime)
              throws <a href="../../../../org/apache/hadoop/security/AccessControlException.html" title="class in org.apache.hadoop.security">AccessControlException</a>,
                     <a href="https://docs.oracle.com/javase/8/docs/api/java/io/FileNotFoundException.html?is-external=true" title="class or interface in java.io">FileNotFoundException</a>,
                     <a href="../../../../org/apache/hadoop/fs/UnsupportedFileSystemException.html" title="class in org.apache.hadoop.fs">UnsupportedFileSystemException</a>,
                     <a href="https://docs.oracle.com/javase/8/docs/api/java/io/IOException.html?is-external=true" title="class or interface in java.io">IOException</a></pre>
<div class="block">Set access time of a file.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>f</code> - The path</dd>
<dd><code>mtime</code> - Set the modification time of this file.
        The number of milliseconds since epoch (Jan 1, 1970). 
        A value of -1 means that this call should not set modification time.</dd>
<dd><code>atime</code> - Set the access time of this file.
        The number of milliseconds since Jan 1, 1970. 
        A value of -1 means that this call should not set access time.</dd>
<dt><span class="throwsLabel">Throws:</span></dt>
<dd><code><a href="../../../../org/apache/hadoop/security/AccessControlException.html" title="class in org.apache.hadoop.security">AccessControlException</a></code> - If access is denied</dd>
<dd><code><a href="https://docs.oracle.com/javase/8/docs/api/java/io/FileNotFoundException.html?is-external=true" title="class or interface in java.io">FileNotFoundException</a></code> - If <code>f</code> does not exist</dd>
<dd><code><a href="../../../../org/apache/hadoop/fs/UnsupportedFileSystemException.html" title="class in org.apache.hadoop.fs">UnsupportedFileSystemException</a></code> - If file system for <code>f</code> is
           not supported</dd>
<dd><code><a href="https://docs.oracle.com/javase/8/docs/api/java/io/IOException.html?is-external=true" title="class or interface in java.io">IOException</a></code> - If an I/O error occurred
 
 Exceptions applicable to file systems accessed over RPC:</dd>
<dd><code><a href="../../../../org/apache/hadoop/ipc/RpcClientException.html" title="class in org.apache.hadoop.ipc">RpcClientException</a></code> - If an exception occurred in the RPC client</dd>
<dd><code><a href="../../../../org/apache/hadoop/ipc/RpcServerException.html" title="class in org.apache.hadoop.ipc">RpcServerException</a></code> - If an exception occurred in the RPC server</dd>
<dd><code><a href="../../../../org/apache/hadoop/ipc/UnexpectedServerException.html" title="class in org.apache.hadoop.ipc">UnexpectedServerException</a></code> - If server implementation throws 
           undeclared exception to RPC server</dd>
</dl>
</li>
</ul>
<a name="getFileChecksum-org.apache.hadoop.fs.Path-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>getFileChecksum</h4>
<pre>public&nbsp;<a href="../../../../org/apache/hadoop/fs/FileChecksum.html" title="class in org.apache.hadoop.fs">FileChecksum</a>&nbsp;getFileChecksum(<a href="../../../../org/apache/hadoop/fs/Path.html" title="class in org.apache.hadoop.fs">Path</a>&nbsp;f)
                             throws <a href="../../../../org/apache/hadoop/security/AccessControlException.html" title="class in org.apache.hadoop.security">AccessControlException</a>,
                                    <a href="https://docs.oracle.com/javase/8/docs/api/java/io/FileNotFoundException.html?is-external=true" title="class or interface in java.io">FileNotFoundException</a>,
                                    <a href="https://docs.oracle.com/javase/8/docs/api/java/io/IOException.html?is-external=true" title="class or interface in java.io">IOException</a></pre>
<div class="block">Get the checksum of a file.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>f</code> - file path</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>The file checksum.  The default return value is null,
  which indicates that no checksum algorithm is implemented
  in the corresponding FileSystem.</dd>
<dt><span class="throwsLabel">Throws:</span></dt>
<dd><code><a href="../../../../org/apache/hadoop/security/AccessControlException.html" title="class in org.apache.hadoop.security">AccessControlException</a></code> - If access is denied</dd>
<dd><code><a href="https://docs.oracle.com/javase/8/docs/api/java/io/FileNotFoundException.html?is-external=true" title="class or interface in java.io">FileNotFoundException</a></code> - If <code>f</code> does not exist</dd>
<dd><code><a href="https://docs.oracle.com/javase/8/docs/api/java/io/IOException.html?is-external=true" title="class or interface in java.io">IOException</a></code> - If an I/O error occurred
 
 Exceptions applicable to file systems accessed over RPC:</dd>
<dd><code><a href="../../../../org/apache/hadoop/ipc/RpcClientException.html" title="class in org.apache.hadoop.ipc">RpcClientException</a></code> - If an exception occurred in the RPC client</dd>
<dd><code><a href="../../../../org/apache/hadoop/ipc/RpcServerException.html" title="class in org.apache.hadoop.ipc">RpcServerException</a></code> - If an exception occurred in the RPC server</dd>
<dd><code><a href="../../../../org/apache/hadoop/ipc/UnexpectedServerException.html" title="class in org.apache.hadoop.ipc">UnexpectedServerException</a></code> - If server implementation throws 
           undeclared exception to RPC server</dd>
</dl>
</li>
</ul>
<a name="setVerifyChecksum-boolean-org.apache.hadoop.fs.Path-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>setVerifyChecksum</h4>
<pre>public&nbsp;void&nbsp;setVerifyChecksum(boolean&nbsp;verifyChecksum,
                              <a href="../../../../org/apache/hadoop/fs/Path.html" title="class in org.apache.hadoop.fs">Path</a>&nbsp;f)
                       throws <a href="../../../../org/apache/hadoop/security/AccessControlException.html" title="class in org.apache.hadoop.security">AccessControlException</a>,
                              <a href="https://docs.oracle.com/javase/8/docs/api/java/io/FileNotFoundException.html?is-external=true" title="class or interface in java.io">FileNotFoundException</a>,
                              <a href="../../../../org/apache/hadoop/fs/UnsupportedFileSystemException.html" title="class in org.apache.hadoop.fs">UnsupportedFileSystemException</a>,
                              <a href="https://docs.oracle.com/javase/8/docs/api/java/io/IOException.html?is-external=true" title="class or interface in java.io">IOException</a></pre>
<div class="block">Set the verify checksum flag for the  file system denoted by the path.
 This is only applicable if the 
 corresponding FileSystem supports checksum. By default doesn't do anything.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>verifyChecksum</code> - </dd>
<dd><code>f</code> - set the verifyChecksum for the Filesystem containing this path</dd>
<dt><span class="throwsLabel">Throws:</span></dt>
<dd><code><a href="../../../../org/apache/hadoop/security/AccessControlException.html" title="class in org.apache.hadoop.security">AccessControlException</a></code> - If access is denied</dd>
<dd><code><a href="https://docs.oracle.com/javase/8/docs/api/java/io/FileNotFoundException.html?is-external=true" title="class or interface in java.io">FileNotFoundException</a></code> - If <code>f</code> does not exist</dd>
<dd><code><a href="../../../../org/apache/hadoop/fs/UnsupportedFileSystemException.html" title="class in org.apache.hadoop.fs">UnsupportedFileSystemException</a></code> - If file system for <code>f</code> is
           not supported</dd>
<dd><code><a href="https://docs.oracle.com/javase/8/docs/api/java/io/IOException.html?is-external=true" title="class or interface in java.io">IOException</a></code> - If an I/O error occurred
 
 Exceptions applicable to file systems accessed over RPC:</dd>
<dd><code><a href="../../../../org/apache/hadoop/ipc/RpcClientException.html" title="class in org.apache.hadoop.ipc">RpcClientException</a></code> - If an exception occurred in the RPC client</dd>
<dd><code><a href="../../../../org/apache/hadoop/ipc/RpcServerException.html" title="class in org.apache.hadoop.ipc">RpcServerException</a></code> - If an exception occurred in the RPC server</dd>
<dd><code><a href="../../../../org/apache/hadoop/ipc/UnexpectedServerException.html" title="class in org.apache.hadoop.ipc">UnexpectedServerException</a></code> - If server implementation throws 
           undeclared exception to RPC server</dd>
</dl>
</li>
</ul>
<a name="getFileStatus-org.apache.hadoop.fs.Path-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>getFileStatus</h4>
<pre>public&nbsp;<a href="../../../../org/apache/hadoop/fs/FileStatus.html" title="class in org.apache.hadoop.fs">FileStatus</a>&nbsp;getFileStatus(<a href="../../../../org/apache/hadoop/fs/Path.html" title="class in org.apache.hadoop.fs">Path</a>&nbsp;f)
                         throws <a href="../../../../org/apache/hadoop/security/AccessControlException.html" title="class in org.apache.hadoop.security">AccessControlException</a>,
                                <a href="https://docs.oracle.com/javase/8/docs/api/java/io/FileNotFoundException.html?is-external=true" title="class or interface in java.io">FileNotFoundException</a>,
                                <a href="../../../../org/apache/hadoop/fs/UnsupportedFileSystemException.html" title="class in org.apache.hadoop.fs">UnsupportedFileSystemException</a>,
                                <a href="https://docs.oracle.com/javase/8/docs/api/java/io/IOException.html?is-external=true" title="class or interface in java.io">IOException</a></pre>
<div class="block">Return a file status object that represents the path.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>f</code> - The path we want information from</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>a FileStatus object</dd>
<dt><span class="throwsLabel">Throws:</span></dt>
<dd><code><a href="../../../../org/apache/hadoop/security/AccessControlException.html" title="class in org.apache.hadoop.security">AccessControlException</a></code> - If access is denied</dd>
<dd><code><a href="https://docs.oracle.com/javase/8/docs/api/java/io/FileNotFoundException.html?is-external=true" title="class or interface in java.io">FileNotFoundException</a></code> - If <code>f</code> does not exist</dd>
<dd><code><a href="../../../../org/apache/hadoop/fs/UnsupportedFileSystemException.html" title="class in org.apache.hadoop.fs">UnsupportedFileSystemException</a></code> - If file system for <code>f</code> is
           not supported</dd>
<dd><code><a href="https://docs.oracle.com/javase/8/docs/api/java/io/IOException.html?is-external=true" title="class or interface in java.io">IOException</a></code> - If an I/O error occurred
 
 Exceptions applicable to file systems accessed over RPC:</dd>
<dd><code><a href="../../../../org/apache/hadoop/ipc/RpcClientException.html" title="class in org.apache.hadoop.ipc">RpcClientException</a></code> - If an exception occurred in the RPC client</dd>
<dd><code><a href="../../../../org/apache/hadoop/ipc/RpcServerException.html" title="class in org.apache.hadoop.ipc">RpcServerException</a></code> - If an exception occurred in the RPC server</dd>
<dd><code><a href="../../../../org/apache/hadoop/ipc/UnexpectedServerException.html" title="class in org.apache.hadoop.ipc">UnexpectedServerException</a></code> - If server implementation throws 
           undeclared exception to RPC server</dd>
</dl>
</li>
</ul>
<a name="msync--">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>msync</h4>
<pre>public&nbsp;void&nbsp;msync()
           throws <a href="https://docs.oracle.com/javase/8/docs/api/java/io/IOException.html?is-external=true" title="class or interface in java.io">IOException</a>,
                  <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/UnsupportedOperationException.html?is-external=true" title="class or interface in java.lang">UnsupportedOperationException</a></pre>
<div class="block">Synchronize client metadata state.</div>
<dl>
<dt><span class="throwsLabel">Throws:</span></dt>
<dd><code><a href="https://docs.oracle.com/javase/8/docs/api/java/io/IOException.html?is-external=true" title="class or interface in java.io">IOException</a></code></dd>
<dd><code><a href="https://docs.oracle.com/javase/8/docs/api/java/lang/UnsupportedOperationException.html?is-external=true" title="class or interface in java.lang">UnsupportedOperationException</a></code></dd>
</dl>
</li>
</ul>
<a name="getFileLinkStatus-org.apache.hadoop.fs.Path-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>getFileLinkStatus</h4>
<pre>public&nbsp;<a href="../../../../org/apache/hadoop/fs/FileStatus.html" title="class in org.apache.hadoop.fs">FileStatus</a>&nbsp;getFileLinkStatus(<a href="../../../../org/apache/hadoop/fs/Path.html" title="class in org.apache.hadoop.fs">Path</a>&nbsp;f)
                             throws <a href="../../../../org/apache/hadoop/security/AccessControlException.html" title="class in org.apache.hadoop.security">AccessControlException</a>,
                                    <a href="https://docs.oracle.com/javase/8/docs/api/java/io/FileNotFoundException.html?is-external=true" title="class or interface in java.io">FileNotFoundException</a>,
                                    <a href="../../../../org/apache/hadoop/fs/UnsupportedFileSystemException.html" title="class in org.apache.hadoop.fs">UnsupportedFileSystemException</a>,
                                    <a href="https://docs.oracle.com/javase/8/docs/api/java/io/IOException.html?is-external=true" title="class or interface in java.io">IOException</a></pre>
<div class="block">Return a file status object that represents the path. If the path 
 refers to a symlink then the FileStatus of the symlink is returned.
 The behavior is equivalent to #getFileStatus() if the underlying
 file system does not support symbolic links.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>f</code> - The path we want information from.</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>A FileStatus object</dd>
<dt><span class="throwsLabel">Throws:</span></dt>
<dd><code><a href="../../../../org/apache/hadoop/security/AccessControlException.html" title="class in org.apache.hadoop.security">AccessControlException</a></code> - If access is denied</dd>
<dd><code><a href="https://docs.oracle.com/javase/8/docs/api/java/io/FileNotFoundException.html?is-external=true" title="class or interface in java.io">FileNotFoundException</a></code> - If <code>f</code> does not exist</dd>
<dd><code><a href="../../../../org/apache/hadoop/fs/UnsupportedFileSystemException.html" title="class in org.apache.hadoop.fs">UnsupportedFileSystemException</a></code> - If file system for <code>f</code> is
           not supported</dd>
<dd><code><a href="https://docs.oracle.com/javase/8/docs/api/java/io/IOException.html?is-external=true" title="class or interface in java.io">IOException</a></code> - If an I/O error occurred</dd>
</dl>
</li>
</ul>
<a name="getLinkTarget-org.apache.hadoop.fs.Path-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>getLinkTarget</h4>
<pre>public&nbsp;<a href="../../../../org/apache/hadoop/fs/Path.html" title="class in org.apache.hadoop.fs">Path</a>&nbsp;getLinkTarget(<a href="../../../../org/apache/hadoop/fs/Path.html" title="class in org.apache.hadoop.fs">Path</a>&nbsp;f)
                   throws <a href="../../../../org/apache/hadoop/security/AccessControlException.html" title="class in org.apache.hadoop.security">AccessControlException</a>,
                          <a href="https://docs.oracle.com/javase/8/docs/api/java/io/FileNotFoundException.html?is-external=true" title="class or interface in java.io">FileNotFoundException</a>,
                          <a href="../../../../org/apache/hadoop/fs/UnsupportedFileSystemException.html" title="class in org.apache.hadoop.fs">UnsupportedFileSystemException</a>,
                          <a href="https://docs.oracle.com/javase/8/docs/api/java/io/IOException.html?is-external=true" title="class or interface in java.io">IOException</a></pre>
<div class="block">Returns the target of the given symbolic link as it was specified
 when the link was created.  Links in the path leading up to the
 final path component are resolved transparently.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>f</code> - the path to return the target of</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>The un-interpreted target of the symbolic link.</dd>
<dt><span class="throwsLabel">Throws:</span></dt>
<dd><code><a href="../../../../org/apache/hadoop/security/AccessControlException.html" title="class in org.apache.hadoop.security">AccessControlException</a></code> - If access is denied</dd>
<dd><code><a href="https://docs.oracle.com/javase/8/docs/api/java/io/FileNotFoundException.html?is-external=true" title="class or interface in java.io">FileNotFoundException</a></code> - If path <code>f</code> does not exist</dd>
<dd><code><a href="../../../../org/apache/hadoop/fs/UnsupportedFileSystemException.html" title="class in org.apache.hadoop.fs">UnsupportedFileSystemException</a></code> - If file system for <code>f</code> is
           not supported</dd>
<dd><code><a href="https://docs.oracle.com/javase/8/docs/api/java/io/IOException.html?is-external=true" title="class or interface in java.io">IOException</a></code> - If the given path does not refer to a symlink
           or an I/O error occurred</dd>
</dl>
</li>
</ul>
<a name="getFsStatus-org.apache.hadoop.fs.Path-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>getFsStatus</h4>
<pre>public&nbsp;<a href="../../../../org/apache/hadoop/fs/FsStatus.html" title="class in org.apache.hadoop.fs">FsStatus</a>&nbsp;getFsStatus(<a href="../../../../org/apache/hadoop/fs/Path.html" title="class in org.apache.hadoop.fs">Path</a>&nbsp;f)
                     throws <a href="../../../../org/apache/hadoop/security/AccessControlException.html" title="class in org.apache.hadoop.security">AccessControlException</a>,
                            <a href="https://docs.oracle.com/javase/8/docs/api/java/io/FileNotFoundException.html?is-external=true" title="class or interface in java.io">FileNotFoundException</a>,
                            <a href="../../../../org/apache/hadoop/fs/UnsupportedFileSystemException.html" title="class in org.apache.hadoop.fs">UnsupportedFileSystemException</a>,
                            <a href="https://docs.oracle.com/javase/8/docs/api/java/io/IOException.html?is-external=true" title="class or interface in java.io">IOException</a></pre>
<div class="block">Returns a status object describing the use and capacity of the
 file system denoted by the Parh argument p.
 If the file system has multiple partitions, the
 use and capacity of the partition pointed to by the specified
 path is reflected.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>f</code> - Path for which status should be obtained. null means the
 root partition of the default file system.</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>a FsStatus object</dd>
<dt><span class="throwsLabel">Throws:</span></dt>
<dd><code><a href="../../../../org/apache/hadoop/security/AccessControlException.html" title="class in org.apache.hadoop.security">AccessControlException</a></code> - If access is denied</dd>
<dd><code><a href="https://docs.oracle.com/javase/8/docs/api/java/io/FileNotFoundException.html?is-external=true" title="class or interface in java.io">FileNotFoundException</a></code> - If <code>f</code> does not exist</dd>
<dd><code><a href="../../../../org/apache/hadoop/fs/UnsupportedFileSystemException.html" title="class in org.apache.hadoop.fs">UnsupportedFileSystemException</a></code> - If file system for <code>f</code> is
           not supported</dd>
<dd><code><a href="https://docs.oracle.com/javase/8/docs/api/java/io/IOException.html?is-external=true" title="class or interface in java.io">IOException</a></code> - If an I/O error occurred
 
 Exceptions applicable to file systems accessed over RPC:</dd>
<dd><code><a href="../../../../org/apache/hadoop/ipc/RpcClientException.html" title="class in org.apache.hadoop.ipc">RpcClientException</a></code> - If an exception occurred in the RPC client</dd>
<dd><code><a href="../../../../org/apache/hadoop/ipc/RpcServerException.html" title="class in org.apache.hadoop.ipc">RpcServerException</a></code> - If an exception occurred in the RPC server</dd>
<dd><code><a href="../../../../org/apache/hadoop/ipc/UnexpectedServerException.html" title="class in org.apache.hadoop.ipc">UnexpectedServerException</a></code> - If server implementation throws 
           undeclared exception to RPC server</dd>
</dl>
</li>
</ul>
<a name="createSymlink-org.apache.hadoop.fs.Path-org.apache.hadoop.fs.Path-boolean-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>createSymlink</h4>
<pre>public&nbsp;void&nbsp;createSymlink(<a href="../../../../org/apache/hadoop/fs/Path.html" title="class in org.apache.hadoop.fs">Path</a>&nbsp;target,
                          <a href="../../../../org/apache/hadoop/fs/Path.html" title="class in org.apache.hadoop.fs">Path</a>&nbsp;link,
                          boolean&nbsp;createParent)
                   throws <a href="../../../../org/apache/hadoop/security/AccessControlException.html" title="class in org.apache.hadoop.security">AccessControlException</a>,
                          <a href="../../../../org/apache/hadoop/fs/FileAlreadyExistsException.html" title="class in org.apache.hadoop.fs">FileAlreadyExistsException</a>,
                          <a href="https://docs.oracle.com/javase/8/docs/api/java/io/FileNotFoundException.html?is-external=true" title="class or interface in java.io">FileNotFoundException</a>,
                          <a href="../../../../org/apache/hadoop/fs/ParentNotDirectoryException.html" title="class in org.apache.hadoop.fs">ParentNotDirectoryException</a>,
                          <a href="../../../../org/apache/hadoop/fs/UnsupportedFileSystemException.html" title="class in org.apache.hadoop.fs">UnsupportedFileSystemException</a>,
                          <a href="https://docs.oracle.com/javase/8/docs/api/java/io/IOException.html?is-external=true" title="class or interface in java.io">IOException</a></pre>
<div class="block">Creates a symbolic link to an existing file. An exception is thrown if 
 the symlink exits, the user does not have permission to create symlink,
 or the underlying file system does not support symlinks.
 
 Symlink permissions are ignored, access to a symlink is determined by
 the permissions of the symlink target.
 
 Symlinks in paths leading up to the final path component are resolved 
 transparently. If the final path component refers to a symlink some 
 functions operate on the symlink itself, these are:
 - delete(f) and deleteOnExit(f) - Deletes the symlink.
 - rename(src, dst) - If src refers to a symlink, the symlink is 
   renamed. If dst refers to a symlink, the symlink is over-written.
 - getLinkTarget(f) - Returns the target of the symlink. 
 - getFileLinkStatus(f) - Returns a FileStatus object describing
   the symlink.
 Some functions, create() and mkdir(), expect the final path component
 does not exist. If they are given a path that refers to a symlink that 
 does exist they behave as if the path referred to an existing file or 
 directory. All other functions fully resolve, ie follow, the symlink. 
 These are: open, setReplication, setOwner, setTimes, setWorkingDirectory,
 setPermission, getFileChecksum, setVerifyChecksum, getFileBlockLocations,
 getFsStatus, getFileStatus, exists, and listStatus.
 
 Symlink targets are stored as given to createSymlink, assuming the 
 underlying file system is capable of storing a fully qualified URI.
 Dangling symlinks are permitted. FileContext supports four types of 
 symlink targets, and resolves them as follows
 <pre>
 Given a path referring to a symlink of form:
 
    &lt;---X ---&gt;
   fs://host/A/B/link 
    &lt;-----Y -----&gt;
 
 In this path X is the scheme and authority that identify the file system,
 and Y is the path leading up to the final path component "link". If Y is
 a symlink  itself then let Y' be the target of Y and X' be the scheme and
 authority of Y'. Symlink targets may:
 
 1. Fully qualified URIs
 
 fs://hostX/A/B/file  Resolved according to the target file system.
 
 2. Partially qualified URIs (eg scheme but no host)
 
 fs:///A/B/file  Resolved according to the target file system. Eg resolving
                 a symlink to hdfs:///A results in an exception because
                 HDFS URIs must be fully qualified, while a symlink to 
                 file:///A will not since Hadoop's local file systems 
                 require partially qualified URIs.
 
 3. Relative paths
 
 path  Resolves to [Y'][path]. Eg if Y resolves to hdfs://host/A and path 
       is "../B/file" then [Y'][path] is hdfs://host/B/file
 
 4. Absolute paths
 
 path  Resolves to [X'][path]. Eg if Y resolves hdfs://host/A/B and path
       is "/file" then [X][path] is hdfs://host/file
 </pre></div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>target</code> - the target of the symbolic link</dd>
<dd><code>link</code> - the path to be created that points to target</dd>
<dd><code>createParent</code> - if true then missing parent dirs are created if 
                     false then parent must exist</dd>
<dt><span class="throwsLabel">Throws:</span></dt>
<dd><code><a href="../../../../org/apache/hadoop/security/AccessControlException.html" title="class in org.apache.hadoop.security">AccessControlException</a></code> - If access is denied</dd>
<dd><code><a href="../../../../org/apache/hadoop/fs/FileAlreadyExistsException.html" title="class in org.apache.hadoop.fs">FileAlreadyExistsException</a></code> - If file <code>link</code> already exists</dd>
<dd><code><a href="https://docs.oracle.com/javase/8/docs/api/java/io/FileNotFoundException.html?is-external=true" title="class or interface in java.io">FileNotFoundException</a></code> - If <code>target</code> does not exist</dd>
<dd><code><a href="../../../../org/apache/hadoop/fs/ParentNotDirectoryException.html" title="class in org.apache.hadoop.fs">ParentNotDirectoryException</a></code> - If parent of <code>link</code> is not a
           directory.</dd>
<dd><code><a href="../../../../org/apache/hadoop/fs/UnsupportedFileSystemException.html" title="class in org.apache.hadoop.fs">UnsupportedFileSystemException</a></code> - If file system for 
           <code>target</code> or <code>link</code> is not supported</dd>
<dd><code><a href="https://docs.oracle.com/javase/8/docs/api/java/io/IOException.html?is-external=true" title="class or interface in java.io">IOException</a></code> - If an I/O error occurred</dd>
</dl>
</li>
</ul>
<a name="listStatus-org.apache.hadoop.fs.Path-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>listStatus</h4>
<pre>public&nbsp;<a href="../../../../org/apache/hadoop/fs/RemoteIterator.html" title="interface in org.apache.hadoop.fs">RemoteIterator</a>&lt;<a href="../../../../org/apache/hadoop/fs/FileStatus.html" title="class in org.apache.hadoop.fs">FileStatus</a>&gt;&nbsp;listStatus(<a href="../../../../org/apache/hadoop/fs/Path.html" title="class in org.apache.hadoop.fs">Path</a>&nbsp;f)
                                      throws <a href="../../../../org/apache/hadoop/security/AccessControlException.html" title="class in org.apache.hadoop.security">AccessControlException</a>,
                                             <a href="https://docs.oracle.com/javase/8/docs/api/java/io/FileNotFoundException.html?is-external=true" title="class or interface in java.io">FileNotFoundException</a>,
                                             <a href="../../../../org/apache/hadoop/fs/UnsupportedFileSystemException.html" title="class in org.apache.hadoop.fs">UnsupportedFileSystemException</a>,
                                             <a href="https://docs.oracle.com/javase/8/docs/api/java/io/IOException.html?is-external=true" title="class or interface in java.io">IOException</a></pre>
<div class="block">List the statuses of the files/directories in the given path if the path is
 a directory.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>f</code> - is the path</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>an iterator that traverses statuses of the files/directories 
         in the given path</dd>
<dt><span class="throwsLabel">Throws:</span></dt>
<dd><code><a href="../../../../org/apache/hadoop/security/AccessControlException.html" title="class in org.apache.hadoop.security">AccessControlException</a></code> - If access is denied</dd>
<dd><code><a href="https://docs.oracle.com/javase/8/docs/api/java/io/FileNotFoundException.html?is-external=true" title="class or interface in java.io">FileNotFoundException</a></code> - If <code>f</code> does not exist</dd>
<dd><code><a href="../../../../org/apache/hadoop/fs/UnsupportedFileSystemException.html" title="class in org.apache.hadoop.fs">UnsupportedFileSystemException</a></code> - If file system for <code>f</code> is
           not supported</dd>
<dd><code><a href="https://docs.oracle.com/javase/8/docs/api/java/io/IOException.html?is-external=true" title="class or interface in java.io">IOException</a></code> - If an I/O error occurred
 
 Exceptions applicable to file systems accessed over RPC:</dd>
<dd><code><a href="../../../../org/apache/hadoop/ipc/RpcClientException.html" title="class in org.apache.hadoop.ipc">RpcClientException</a></code> - If an exception occurred in the RPC client</dd>
<dd><code><a href="../../../../org/apache/hadoop/ipc/RpcServerException.html" title="class in org.apache.hadoop.ipc">RpcServerException</a></code> - If an exception occurred in the RPC server</dd>
<dd><code><a href="../../../../org/apache/hadoop/ipc/UnexpectedServerException.html" title="class in org.apache.hadoop.ipc">UnexpectedServerException</a></code> - If server implementation throws 
           undeclared exception to RPC server</dd>
</dl>
</li>
</ul>
<a name="listCorruptFileBlocks-org.apache.hadoop.fs.Path-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>listCorruptFileBlocks</h4>
<pre>public&nbsp;<a href="../../../../org/apache/hadoop/fs/RemoteIterator.html" title="interface in org.apache.hadoop.fs">RemoteIterator</a>&lt;<a href="../../../../org/apache/hadoop/fs/Path.html" title="class in org.apache.hadoop.fs">Path</a>&gt;&nbsp;listCorruptFileBlocks(<a href="../../../../org/apache/hadoop/fs/Path.html" title="class in org.apache.hadoop.fs">Path</a>&nbsp;path)
                                           throws <a href="https://docs.oracle.com/javase/8/docs/api/java/io/IOException.html?is-external=true" title="class or interface in java.io">IOException</a></pre>
<dl>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>an iterator over the corrupt files under the given path
 (may contain duplicates if a file has more than one corrupt block)</dd>
<dt><span class="throwsLabel">Throws:</span></dt>
<dd><code><a href="https://docs.oracle.com/javase/8/docs/api/java/io/IOException.html?is-external=true" title="class or interface in java.io">IOException</a></code></dd>
</dl>
</li>
</ul>
<a name="listLocatedStatus-org.apache.hadoop.fs.Path-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>listLocatedStatus</h4>
<pre>public&nbsp;<a href="../../../../org/apache/hadoop/fs/RemoteIterator.html" title="interface in org.apache.hadoop.fs">RemoteIterator</a>&lt;<a href="../../../../org/apache/hadoop/fs/LocatedFileStatus.html" title="class in org.apache.hadoop.fs">LocatedFileStatus</a>&gt;&nbsp;listLocatedStatus(<a href="../../../../org/apache/hadoop/fs/Path.html" title="class in org.apache.hadoop.fs">Path</a>&nbsp;f)
                                                    throws <a href="../../../../org/apache/hadoop/security/AccessControlException.html" title="class in org.apache.hadoop.security">AccessControlException</a>,
                                                           <a href="https://docs.oracle.com/javase/8/docs/api/java/io/FileNotFoundException.html?is-external=true" title="class or interface in java.io">FileNotFoundException</a>,
                                                           <a href="../../../../org/apache/hadoop/fs/UnsupportedFileSystemException.html" title="class in org.apache.hadoop.fs">UnsupportedFileSystemException</a>,
                                                           <a href="https://docs.oracle.com/javase/8/docs/api/java/io/IOException.html?is-external=true" title="class or interface in java.io">IOException</a></pre>
<div class="block">List the statuses of the files/directories in the given path if the path is
 a directory. 
 Return the file's status and block locations If the path is a file.
 
 If a returned status is a file, it contains the file's block locations.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>f</code> - is the path</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>an iterator that traverses statuses of the files/directories 
         in the given path
 If any IO exception (for example the input directory gets deleted while
 listing is being executed), next() or hasNext() of the returned iterator
 may throw a RuntimeException with the io exception as the cause.</dd>
<dt><span class="throwsLabel">Throws:</span></dt>
<dd><code><a href="../../../../org/apache/hadoop/security/AccessControlException.html" title="class in org.apache.hadoop.security">AccessControlException</a></code> - If access is denied</dd>
<dd><code><a href="https://docs.oracle.com/javase/8/docs/api/java/io/FileNotFoundException.html?is-external=true" title="class or interface in java.io">FileNotFoundException</a></code> - If <code>f</code> does not exist</dd>
<dd><code><a href="../../../../org/apache/hadoop/fs/UnsupportedFileSystemException.html" title="class in org.apache.hadoop.fs">UnsupportedFileSystemException</a></code> - If file system for <code>f</code> is
           not supported</dd>
<dd><code><a href="https://docs.oracle.com/javase/8/docs/api/java/io/IOException.html?is-external=true" title="class or interface in java.io">IOException</a></code> - If an I/O error occurred
 
 Exceptions applicable to file systems accessed over RPC:</dd>
<dd><code><a href="../../../../org/apache/hadoop/ipc/RpcClientException.html" title="class in org.apache.hadoop.ipc">RpcClientException</a></code> - If an exception occurred in the RPC client</dd>
<dd><code><a href="../../../../org/apache/hadoop/ipc/RpcServerException.html" title="class in org.apache.hadoop.ipc">RpcServerException</a></code> - If an exception occurred in the RPC server</dd>
<dd><code><a href="../../../../org/apache/hadoop/ipc/UnexpectedServerException.html" title="class in org.apache.hadoop.ipc">UnexpectedServerException</a></code> - If server implementation throws 
           undeclared exception to RPC server</dd>
</dl>
</li>
</ul>
<a name="deleteOnExit-org.apache.hadoop.fs.Path-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>deleteOnExit</h4>
<pre>public&nbsp;boolean&nbsp;deleteOnExit(<a href="../../../../org/apache/hadoop/fs/Path.html" title="class in org.apache.hadoop.fs">Path</a>&nbsp;f)
                     throws <a href="../../../../org/apache/hadoop/security/AccessControlException.html" title="class in org.apache.hadoop.security">AccessControlException</a>,
                            <a href="https://docs.oracle.com/javase/8/docs/api/java/io/IOException.html?is-external=true" title="class or interface in java.io">IOException</a></pre>
<div class="block">Mark a path to be deleted on JVM shutdown.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>f</code> - the existing path to delete.</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>true if deleteOnExit is successful, otherwise false.</dd>
<dt><span class="throwsLabel">Throws:</span></dt>
<dd><code><a href="../../../../org/apache/hadoop/security/AccessControlException.html" title="class in org.apache.hadoop.security">AccessControlException</a></code> - If access is denied</dd>
<dd><code><a href="../../../../org/apache/hadoop/fs/UnsupportedFileSystemException.html" title="class in org.apache.hadoop.fs">UnsupportedFileSystemException</a></code> - If file system for <code>f</code> is
           not supported</dd>
<dd><code><a href="https://docs.oracle.com/javase/8/docs/api/java/io/IOException.html?is-external=true" title="class or interface in java.io">IOException</a></code> - If an I/O error occurred
 
 Exceptions applicable to file systems accessed over RPC:</dd>
<dd><code><a href="../../../../org/apache/hadoop/ipc/RpcClientException.html" title="class in org.apache.hadoop.ipc">RpcClientException</a></code> - If an exception occurred in the RPC client</dd>
<dd><code><a href="../../../../org/apache/hadoop/ipc/RpcServerException.html" title="class in org.apache.hadoop.ipc">RpcServerException</a></code> - If an exception occurred in the RPC server</dd>
<dd><code><a href="../../../../org/apache/hadoop/ipc/UnexpectedServerException.html" title="class in org.apache.hadoop.ipc">UnexpectedServerException</a></code> - If server implementation throws 
           undeclared exception to RPC server</dd>
</dl>
</li>
</ul>
<a name="util--">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>util</h4>
<pre>public&nbsp;<a href="../../../../org/apache/hadoop/fs/FileContext.Util.html" title="class in org.apache.hadoop.fs">FileContext.Util</a>&nbsp;util()</pre>
</li>
</ul>
<a name="resolve-org.apache.hadoop.fs.Path-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>resolve</h4>
<pre>protected&nbsp;<a href="../../../../org/apache/hadoop/fs/Path.html" title="class in org.apache.hadoop.fs">Path</a>&nbsp;resolve(<a href="../../../../org/apache/hadoop/fs/Path.html" title="class in org.apache.hadoop.fs">Path</a>&nbsp;f)
                throws <a href="https://docs.oracle.com/javase/8/docs/api/java/io/FileNotFoundException.html?is-external=true" title="class or interface in java.io">FileNotFoundException</a>,
                       org.apache.hadoop.fs.UnresolvedLinkException,
                       <a href="../../../../org/apache/hadoop/security/AccessControlException.html" title="class in org.apache.hadoop.security">AccessControlException</a>,
                       <a href="https://docs.oracle.com/javase/8/docs/api/java/io/IOException.html?is-external=true" title="class or interface in java.io">IOException</a></pre>
<div class="block">Resolves all symbolic links in the specified path.
 Returns the new path object.</div>
<dl>
<dt><span class="throwsLabel">Throws:</span></dt>
<dd><code><a href="https://docs.oracle.com/javase/8/docs/api/java/io/FileNotFoundException.html?is-external=true" title="class or interface in java.io">FileNotFoundException</a></code></dd>
<dd><code>org.apache.hadoop.fs.UnresolvedLinkException</code></dd>
<dd><code><a href="../../../../org/apache/hadoop/security/AccessControlException.html" title="class in org.apache.hadoop.security">AccessControlException</a></code></dd>
<dd><code><a href="https://docs.oracle.com/javase/8/docs/api/java/io/IOException.html?is-external=true" title="class or interface in java.io">IOException</a></code></dd>
</dl>
</li>
</ul>
<a name="resolveIntermediate-org.apache.hadoop.fs.Path-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>resolveIntermediate</h4>
<pre>protected&nbsp;<a href="../../../../org/apache/hadoop/fs/Path.html" title="class in org.apache.hadoop.fs">Path</a>&nbsp;resolveIntermediate(<a href="../../../../org/apache/hadoop/fs/Path.html" title="class in org.apache.hadoop.fs">Path</a>&nbsp;f)
                            throws <a href="https://docs.oracle.com/javase/8/docs/api/java/io/IOException.html?is-external=true" title="class or interface in java.io">IOException</a></pre>
<div class="block">Resolves all symbolic links in the specified path leading up 
 to, but not including the final path component.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>f</code> - path to resolve</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>the new path object.</dd>
<dt><span class="throwsLabel">Throws:</span></dt>
<dd><code><a href="https://docs.oracle.com/javase/8/docs/api/java/io/IOException.html?is-external=true" title="class or interface in java.io">IOException</a></code></dd>
</dl>
</li>
</ul>
<a name="getStatistics-java.net.URI-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>getStatistics</h4>
<pre>public static&nbsp;<a href="../../../../org/apache/hadoop/fs/FileSystem.Statistics.html" title="class in org.apache.hadoop.fs">FileSystem.Statistics</a>&nbsp;getStatistics(<a href="https://docs.oracle.com/javase/8/docs/api/java/net/URI.html?is-external=true" title="class or interface in java.net">URI</a>&nbsp;uri)</pre>
<div class="block">Get the statistics for a particular file system</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>uri</code> - the uri to lookup the statistics. Only scheme and authority part
          of the uri are used as the key to store and lookup.</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>a statistics object</dd>
</dl>
</li>
</ul>
<a name="clearStatistics--">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>clearStatistics</h4>
<pre>public static&nbsp;void&nbsp;clearStatistics()</pre>
<div class="block">Clears all the statistics stored in AbstractFileSystem, for all the file
 systems.</div>
</li>
</ul>
<a name="printStatistics--">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>printStatistics</h4>
<pre>public static&nbsp;void&nbsp;printStatistics()</pre>
<div class="block">Prints the statistics to standard output. File System is identified by the
 scheme and authority.</div>
</li>
</ul>
<a name="getAllStatistics--">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>getAllStatistics</h4>
<pre>public static&nbsp;<a href="https://docs.oracle.com/javase/8/docs/api/java/util/Map.html?is-external=true" title="class or interface in java.util">Map</a>&lt;<a href="https://docs.oracle.com/javase/8/docs/api/java/net/URI.html?is-external=true" title="class or interface in java.net">URI</a>,<a href="../../../../org/apache/hadoop/fs/FileSystem.Statistics.html" title="class in org.apache.hadoop.fs">FileSystem.Statistics</a>&gt;&nbsp;getAllStatistics()</pre>
<dl>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>Map of uri and statistics for each filesystem instantiated. The uri
         consists of scheme and authority for the filesystem.</dd>
</dl>
</li>
</ul>
<a name="modifyAclEntries-org.apache.hadoop.fs.Path-java.util.List-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>modifyAclEntries</h4>
<pre>public&nbsp;void&nbsp;modifyAclEntries(<a href="../../../../org/apache/hadoop/fs/Path.html" title="class in org.apache.hadoop.fs">Path</a>&nbsp;path,
                             <a href="https://docs.oracle.com/javase/8/docs/api/java/util/List.html?is-external=true" title="class or interface in java.util">List</a>&lt;<a href="../../../../org/apache/hadoop/fs/permission/AclEntry.html" title="class in org.apache.hadoop.fs.permission">AclEntry</a>&gt;&nbsp;aclSpec)
                      throws <a href="https://docs.oracle.com/javase/8/docs/api/java/io/IOException.html?is-external=true" title="class or interface in java.io">IOException</a></pre>
<div class="block">Modifies ACL entries of files and directories.  This method can add new ACL
 entries or modify the permissions on existing ACL entries.  All existing
 ACL entries that are not specified in this call are retained without
 changes.  (Modifications are merged into the current ACL.)</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>path</code> - Path to modify</dd>
<dd><code>aclSpec</code> - List&lt;AclEntry&gt; describing
 modifications</dd>
<dt><span class="throwsLabel">Throws:</span></dt>
<dd><code><a href="https://docs.oracle.com/javase/8/docs/api/java/io/IOException.html?is-external=true" title="class or interface in java.io">IOException</a></code> - if an ACL could not be modified</dd>
</dl>
</li>
</ul>
<a name="removeAclEntries-org.apache.hadoop.fs.Path-java.util.List-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>removeAclEntries</h4>
<pre>public&nbsp;void&nbsp;removeAclEntries(<a href="../../../../org/apache/hadoop/fs/Path.html" title="class in org.apache.hadoop.fs">Path</a>&nbsp;path,
                             <a href="https://docs.oracle.com/javase/8/docs/api/java/util/List.html?is-external=true" title="class or interface in java.util">List</a>&lt;<a href="../../../../org/apache/hadoop/fs/permission/AclEntry.html" title="class in org.apache.hadoop.fs.permission">AclEntry</a>&gt;&nbsp;aclSpec)
                      throws <a href="https://docs.oracle.com/javase/8/docs/api/java/io/IOException.html?is-external=true" title="class or interface in java.io">IOException</a></pre>
<div class="block">Removes ACL entries from files and directories.  Other ACL entries are
 retained.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>path</code> - Path to modify</dd>
<dd><code>aclSpec</code> - List&lt;AclEntry&gt; describing entries
 to remove</dd>
<dt><span class="throwsLabel">Throws:</span></dt>
<dd><code><a href="https://docs.oracle.com/javase/8/docs/api/java/io/IOException.html?is-external=true" title="class or interface in java.io">IOException</a></code> - if an ACL could not be modified</dd>
</dl>
</li>
</ul>
<a name="removeDefaultAcl-org.apache.hadoop.fs.Path-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>removeDefaultAcl</h4>
<pre>public&nbsp;void&nbsp;removeDefaultAcl(<a href="../../../../org/apache/hadoop/fs/Path.html" title="class in org.apache.hadoop.fs">Path</a>&nbsp;path)
                      throws <a href="https://docs.oracle.com/javase/8/docs/api/java/io/IOException.html?is-external=true" title="class or interface in java.io">IOException</a></pre>
<div class="block">Removes all default ACL entries from files and directories.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>path</code> - Path to modify</dd>
<dt><span class="throwsLabel">Throws:</span></dt>
<dd><code><a href="https://docs.oracle.com/javase/8/docs/api/java/io/IOException.html?is-external=true" title="class or interface in java.io">IOException</a></code> - if an ACL could not be modified</dd>
</dl>
</li>
</ul>
<a name="removeAcl-org.apache.hadoop.fs.Path-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>removeAcl</h4>
<pre>public&nbsp;void&nbsp;removeAcl(<a href="../../../../org/apache/hadoop/fs/Path.html" title="class in org.apache.hadoop.fs">Path</a>&nbsp;path)
               throws <a href="https://docs.oracle.com/javase/8/docs/api/java/io/IOException.html?is-external=true" title="class or interface in java.io">IOException</a></pre>
<div class="block">Removes all but the base ACL entries of files and directories.  The entries
 for user, group, and others are retained for compatibility with permission
 bits.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>path</code> - Path to modify</dd>
<dt><span class="throwsLabel">Throws:</span></dt>
<dd><code><a href="https://docs.oracle.com/javase/8/docs/api/java/io/IOException.html?is-external=true" title="class or interface in java.io">IOException</a></code> - if an ACL could not be removed</dd>
</dl>
</li>
</ul>
<a name="setAcl-org.apache.hadoop.fs.Path-java.util.List-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>setAcl</h4>
<pre>public&nbsp;void&nbsp;setAcl(<a href="../../../../org/apache/hadoop/fs/Path.html" title="class in org.apache.hadoop.fs">Path</a>&nbsp;path,
                   <a href="https://docs.oracle.com/javase/8/docs/api/java/util/List.html?is-external=true" title="class or interface in java.util">List</a>&lt;<a href="../../../../org/apache/hadoop/fs/permission/AclEntry.html" title="class in org.apache.hadoop.fs.permission">AclEntry</a>&gt;&nbsp;aclSpec)
            throws <a href="https://docs.oracle.com/javase/8/docs/api/java/io/IOException.html?is-external=true" title="class or interface in java.io">IOException</a></pre>
<div class="block">Fully replaces ACL of files and directories, discarding all existing
 entries.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>path</code> - Path to modify</dd>
<dd><code>aclSpec</code> - List&lt;AclEntry&gt; describing
 modifications, must include entries for user, group, and others for
 compatibility with permission bits.</dd>
<dt><span class="throwsLabel">Throws:</span></dt>
<dd><code><a href="https://docs.oracle.com/javase/8/docs/api/java/io/IOException.html?is-external=true" title="class or interface in java.io">IOException</a></code> - if an ACL could not be modified</dd>
</dl>
</li>
</ul>
<a name="getAclStatus-org.apache.hadoop.fs.Path-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>getAclStatus</h4>
<pre>public&nbsp;<a href="../../../../org/apache/hadoop/fs/permission/AclStatus.html" title="class in org.apache.hadoop.fs.permission">AclStatus</a>&nbsp;getAclStatus(<a href="../../../../org/apache/hadoop/fs/Path.html" title="class in org.apache.hadoop.fs">Path</a>&nbsp;path)
                       throws <a href="https://docs.oracle.com/javase/8/docs/api/java/io/IOException.html?is-external=true" title="class or interface in java.io">IOException</a></pre>
<div class="block">Gets the ACLs of files and directories.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>path</code> - Path to get</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>RemoteIterator&lt;AclStatus&gt; which returns
         each AclStatus</dd>
<dt><span class="throwsLabel">Throws:</span></dt>
<dd><code><a href="https://docs.oracle.com/javase/8/docs/api/java/io/IOException.html?is-external=true" title="class or interface in java.io">IOException</a></code> - if an ACL could not be read</dd>
</dl>
</li>
</ul>
<a name="setXAttr-org.apache.hadoop.fs.Path-java.lang.String-byte:A-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>setXAttr</h4>
<pre>public&nbsp;void&nbsp;setXAttr(<a href="../../../../org/apache/hadoop/fs/Path.html" title="class in org.apache.hadoop.fs">Path</a>&nbsp;path,
                     <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&nbsp;name,
                     byte[]&nbsp;value)
              throws <a href="https://docs.oracle.com/javase/8/docs/api/java/io/IOException.html?is-external=true" title="class or interface in java.io">IOException</a></pre>
<div class="block">Set an xattr of a file or directory.
 The name must be prefixed with the namespace followed by ".". For example,
 "user.attr".
 <p>
 Refer to the HDFS extended attributes user documentation for details.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>path</code> - Path to modify</dd>
<dd><code>name</code> - xattr name.</dd>
<dd><code>value</code> - xattr value.</dd>
<dt><span class="throwsLabel">Throws:</span></dt>
<dd><code><a href="https://docs.oracle.com/javase/8/docs/api/java/io/IOException.html?is-external=true" title="class or interface in java.io">IOException</a></code></dd>
</dl>
</li>
</ul>
<a name="setXAttr-org.apache.hadoop.fs.Path-java.lang.String-byte:A-java.util.EnumSet-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>setXAttr</h4>
<pre>public&nbsp;void&nbsp;setXAttr(<a href="../../../../org/apache/hadoop/fs/Path.html" title="class in org.apache.hadoop.fs">Path</a>&nbsp;path,
                     <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&nbsp;name,
                     byte[]&nbsp;value,
                     <a href="https://docs.oracle.com/javase/8/docs/api/java/util/EnumSet.html?is-external=true" title="class or interface in java.util">EnumSet</a>&lt;<a href="../../../../org/apache/hadoop/fs/XAttrSetFlag.html" title="enum in org.apache.hadoop.fs">XAttrSetFlag</a>&gt;&nbsp;flag)
              throws <a href="https://docs.oracle.com/javase/8/docs/api/java/io/IOException.html?is-external=true" title="class or interface in java.io">IOException</a></pre>
<div class="block">Set an xattr of a file or directory.
 The name must be prefixed with the namespace followed by ".". For example,
 "user.attr".
 <p>
 Refer to the HDFS extended attributes user documentation for details.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>path</code> - Path to modify</dd>
<dd><code>name</code> - xattr name.</dd>
<dd><code>value</code> - xattr value.</dd>
<dd><code>flag</code> - xattr set flag</dd>
<dt><span class="throwsLabel">Throws:</span></dt>
<dd><code><a href="https://docs.oracle.com/javase/8/docs/api/java/io/IOException.html?is-external=true" title="class or interface in java.io">IOException</a></code></dd>
</dl>
</li>
</ul>
<a name="getXAttr-org.apache.hadoop.fs.Path-java.lang.String-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>getXAttr</h4>
<pre>public&nbsp;byte[]&nbsp;getXAttr(<a href="../../../../org/apache/hadoop/fs/Path.html" title="class in org.apache.hadoop.fs">Path</a>&nbsp;path,
                       <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&nbsp;name)
                throws <a href="https://docs.oracle.com/javase/8/docs/api/java/io/IOException.html?is-external=true" title="class or interface in java.io">IOException</a></pre>
<div class="block">Get an xattr for a file or directory.
 The name must be prefixed with the namespace followed by ".". For example,
 "user.attr".
 <p>
 Refer to the HDFS extended attributes user documentation for details.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>path</code> - Path to get extended attribute</dd>
<dd><code>name</code> - xattr name.</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>byte[] xattr value.</dd>
<dt><span class="throwsLabel">Throws:</span></dt>
<dd><code><a href="https://docs.oracle.com/javase/8/docs/api/java/io/IOException.html?is-external=true" title="class or interface in java.io">IOException</a></code></dd>
</dl>
</li>
</ul>
<a name="getXAttrs-org.apache.hadoop.fs.Path-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>getXAttrs</h4>
<pre>public&nbsp;<a href="https://docs.oracle.com/javase/8/docs/api/java/util/Map.html?is-external=true" title="class or interface in java.util">Map</a>&lt;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>,byte[]&gt;&nbsp;getXAttrs(<a href="../../../../org/apache/hadoop/fs/Path.html" title="class in org.apache.hadoop.fs">Path</a>&nbsp;path)
                             throws <a href="https://docs.oracle.com/javase/8/docs/api/java/io/IOException.html?is-external=true" title="class or interface in java.io">IOException</a></pre>
<div class="block">Get all of the xattrs for a file or directory.
 Only those xattrs for which the logged-in user has permissions to view
 are returned.
 <p>
 Refer to the HDFS extended attributes user documentation for details.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>path</code> - Path to get extended attributes</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>Map&lt;String, byte[]&gt; describing the XAttrs
 of the file or directory</dd>
<dt><span class="throwsLabel">Throws:</span></dt>
<dd><code><a href="https://docs.oracle.com/javase/8/docs/api/java/io/IOException.html?is-external=true" title="class or interface in java.io">IOException</a></code></dd>
</dl>
</li>
</ul>
<a name="getXAttrs-org.apache.hadoop.fs.Path-java.util.List-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>getXAttrs</h4>
<pre>public&nbsp;<a href="https://docs.oracle.com/javase/8/docs/api/java/util/Map.html?is-external=true" title="class or interface in java.util">Map</a>&lt;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>,byte[]&gt;&nbsp;getXAttrs(<a href="../../../../org/apache/hadoop/fs/Path.html" title="class in org.apache.hadoop.fs">Path</a>&nbsp;path,
                                    <a href="https://docs.oracle.com/javase/8/docs/api/java/util/List.html?is-external=true" title="class or interface in java.util">List</a>&lt;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&gt;&nbsp;names)
                             throws <a href="https://docs.oracle.com/javase/8/docs/api/java/io/IOException.html?is-external=true" title="class or interface in java.io">IOException</a></pre>
<div class="block">Get all of the xattrs for a file or directory.
 Only those xattrs for which the logged-in user has permissions to view
 are returned.
 <p>
 Refer to the HDFS extended attributes user documentation for details.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>path</code> - Path to get extended attributes</dd>
<dd><code>names</code> - XAttr names.</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>Map&lt;String, byte[]&gt; describing the XAttrs
 of the file or directory</dd>
<dt><span class="throwsLabel">Throws:</span></dt>
<dd><code><a href="https://docs.oracle.com/javase/8/docs/api/java/io/IOException.html?is-external=true" title="class or interface in java.io">IOException</a></code></dd>
</dl>
</li>
</ul>
<a name="removeXAttr-org.apache.hadoop.fs.Path-java.lang.String-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>removeXAttr</h4>
<pre>public&nbsp;void&nbsp;removeXAttr(<a href="../../../../org/apache/hadoop/fs/Path.html" title="class in org.apache.hadoop.fs">Path</a>&nbsp;path,
                        <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&nbsp;name)
                 throws <a href="https://docs.oracle.com/javase/8/docs/api/java/io/IOException.html?is-external=true" title="class or interface in java.io">IOException</a></pre>
<div class="block">Remove an xattr of a file or directory.
 The name must be prefixed with the namespace followed by ".". For example,
 "user.attr".
 <p>
 Refer to the HDFS extended attributes user documentation for details.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>path</code> - Path to remove extended attribute</dd>
<dd><code>name</code> - xattr name</dd>
<dt><span class="throwsLabel">Throws:</span></dt>
<dd><code><a href="https://docs.oracle.com/javase/8/docs/api/java/io/IOException.html?is-external=true" title="class or interface in java.io">IOException</a></code></dd>
</dl>
</li>
</ul>
<a name="listXAttrs-org.apache.hadoop.fs.Path-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>listXAttrs</h4>
<pre>public&nbsp;<a href="https://docs.oracle.com/javase/8/docs/api/java/util/List.html?is-external=true" title="class or interface in java.util">List</a>&lt;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&gt;&nbsp;listXAttrs(<a href="../../../../org/apache/hadoop/fs/Path.html" title="class in org.apache.hadoop.fs">Path</a>&nbsp;path)
                        throws <a href="https://docs.oracle.com/javase/8/docs/api/java/io/IOException.html?is-external=true" title="class or interface in java.io">IOException</a></pre>
<div class="block">Get all of the xattr names for a file or directory.
 Only those xattr names which the logged-in user has permissions to view
 are returned.
 <p>
 Refer to the HDFS extended attributes user documentation for details.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>path</code> - Path to get extended attributes</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>List&lt;String&gt; of the XAttr names of the
 file or directory</dd>
<dt><span class="throwsLabel">Throws:</span></dt>
<dd><code><a href="https://docs.oracle.com/javase/8/docs/api/java/io/IOException.html?is-external=true" title="class or interface in java.io">IOException</a></code></dd>
</dl>
</li>
</ul>
<a name="createSnapshot-org.apache.hadoop.fs.Path-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>createSnapshot</h4>
<pre>public final&nbsp;<a href="../../../../org/apache/hadoop/fs/Path.html" title="class in org.apache.hadoop.fs">Path</a>&nbsp;createSnapshot(<a href="../../../../org/apache/hadoop/fs/Path.html" title="class in org.apache.hadoop.fs">Path</a>&nbsp;path)
                          throws <a href="https://docs.oracle.com/javase/8/docs/api/java/io/IOException.html?is-external=true" title="class or interface in java.io">IOException</a></pre>
<div class="block">Create a snapshot with a default name.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>path</code> - The directory where snapshots will be taken.</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>the snapshot path.</dd>
<dt><span class="throwsLabel">Throws:</span></dt>
<dd><code><a href="https://docs.oracle.com/javase/8/docs/api/java/io/IOException.html?is-external=true" title="class or interface in java.io">IOException</a></code> - If an I/O error occurred

 <p>Exceptions applicable to file systems accessed over RPC:</dd>
<dd><code><a href="../../../../org/apache/hadoop/ipc/RpcClientException.html" title="class in org.apache.hadoop.ipc">RpcClientException</a></code> - If an exception occurred in the RPC client</dd>
<dd><code><a href="../../../../org/apache/hadoop/ipc/RpcServerException.html" title="class in org.apache.hadoop.ipc">RpcServerException</a></code> - If an exception occurred in the RPC server</dd>
<dd><code><a href="../../../../org/apache/hadoop/ipc/UnexpectedServerException.html" title="class in org.apache.hadoop.ipc">UnexpectedServerException</a></code> - If server implementation throws
           undeclared exception to RPC server</dd>
</dl>
</li>
</ul>
<a name="createSnapshot-org.apache.hadoop.fs.Path-java.lang.String-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>createSnapshot</h4>
<pre>public&nbsp;<a href="../../../../org/apache/hadoop/fs/Path.html" title="class in org.apache.hadoop.fs">Path</a>&nbsp;createSnapshot(<a href="../../../../org/apache/hadoop/fs/Path.html" title="class in org.apache.hadoop.fs">Path</a>&nbsp;path,
                           <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&nbsp;snapshotName)
                    throws <a href="https://docs.oracle.com/javase/8/docs/api/java/io/IOException.html?is-external=true" title="class or interface in java.io">IOException</a></pre>
<div class="block">Create a snapshot.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>path</code> - The directory where snapshots will be taken.</dd>
<dd><code>snapshotName</code> - The name of the snapshot</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>the snapshot path.</dd>
<dt><span class="throwsLabel">Throws:</span></dt>
<dd><code><a href="https://docs.oracle.com/javase/8/docs/api/java/io/IOException.html?is-external=true" title="class or interface in java.io">IOException</a></code> - If an I/O error occurred

 <p>Exceptions applicable to file systems accessed over RPC:</dd>
<dd><code><a href="../../../../org/apache/hadoop/ipc/RpcClientException.html" title="class in org.apache.hadoop.ipc">RpcClientException</a></code> - If an exception occurred in the RPC client</dd>
<dd><code><a href="../../../../org/apache/hadoop/ipc/RpcServerException.html" title="class in org.apache.hadoop.ipc">RpcServerException</a></code> - If an exception occurred in the RPC server</dd>
<dd><code><a href="../../../../org/apache/hadoop/ipc/UnexpectedServerException.html" title="class in org.apache.hadoop.ipc">UnexpectedServerException</a></code> - If server implementation throws
           undeclared exception to RPC server</dd>
</dl>
</li>
</ul>
<a name="renameSnapshot-org.apache.hadoop.fs.Path-java.lang.String-java.lang.String-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>renameSnapshot</h4>
<pre>public&nbsp;void&nbsp;renameSnapshot(<a href="../../../../org/apache/hadoop/fs/Path.html" title="class in org.apache.hadoop.fs">Path</a>&nbsp;path,
                           <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&nbsp;snapshotOldName,
                           <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&nbsp;snapshotNewName)
                    throws <a href="https://docs.oracle.com/javase/8/docs/api/java/io/IOException.html?is-external=true" title="class or interface in java.io">IOException</a></pre>
<div class="block">Rename a snapshot.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>path</code> - The directory path where the snapshot was taken</dd>
<dd><code>snapshotOldName</code> - Old name of the snapshot</dd>
<dd><code>snapshotNewName</code> - New name of the snapshot</dd>
<dt><span class="throwsLabel">Throws:</span></dt>
<dd><code><a href="https://docs.oracle.com/javase/8/docs/api/java/io/IOException.html?is-external=true" title="class or interface in java.io">IOException</a></code> - If an I/O error occurred

 <p>Exceptions applicable to file systems accessed over RPC:</dd>
<dd><code><a href="../../../../org/apache/hadoop/ipc/RpcClientException.html" title="class in org.apache.hadoop.ipc">RpcClientException</a></code> - If an exception occurred in the RPC client</dd>
<dd><code><a href="../../../../org/apache/hadoop/ipc/RpcServerException.html" title="class in org.apache.hadoop.ipc">RpcServerException</a></code> - If an exception occurred in the RPC server</dd>
<dd><code><a href="../../../../org/apache/hadoop/ipc/UnexpectedServerException.html" title="class in org.apache.hadoop.ipc">UnexpectedServerException</a></code> - If server implementation throws
           undeclared exception to RPC server</dd>
</dl>
</li>
</ul>
<a name="deleteSnapshot-org.apache.hadoop.fs.Path-java.lang.String-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>deleteSnapshot</h4>
<pre>public&nbsp;void&nbsp;deleteSnapshot(<a href="../../../../org/apache/hadoop/fs/Path.html" title="class in org.apache.hadoop.fs">Path</a>&nbsp;path,
                           <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&nbsp;snapshotName)
                    throws <a href="https://docs.oracle.com/javase/8/docs/api/java/io/IOException.html?is-external=true" title="class or interface in java.io">IOException</a></pre>
<div class="block">Delete a snapshot of a directory.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>path</code> - The directory that the to-be-deleted snapshot belongs to</dd>
<dd><code>snapshotName</code> - The name of the snapshot</dd>
<dt><span class="throwsLabel">Throws:</span></dt>
<dd><code><a href="https://docs.oracle.com/javase/8/docs/api/java/io/IOException.html?is-external=true" title="class or interface in java.io">IOException</a></code> - If an I/O error occurred

 <p>Exceptions applicable to file systems accessed over RPC:</dd>
<dd><code><a href="../../../../org/apache/hadoop/ipc/RpcClientException.html" title="class in org.apache.hadoop.ipc">RpcClientException</a></code> - If an exception occurred in the RPC client</dd>
<dd><code><a href="../../../../org/apache/hadoop/ipc/RpcServerException.html" title="class in org.apache.hadoop.ipc">RpcServerException</a></code> - If an exception occurred in the RPC server</dd>
<dd><code><a href="../../../../org/apache/hadoop/ipc/UnexpectedServerException.html" title="class in org.apache.hadoop.ipc">UnexpectedServerException</a></code> - If server implementation throws
           undeclared exception to RPC server</dd>
</dl>
</li>
</ul>
<a name="satisfyStoragePolicy-org.apache.hadoop.fs.Path-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>satisfyStoragePolicy</h4>
<pre>public&nbsp;void&nbsp;satisfyStoragePolicy(<a href="../../../../org/apache/hadoop/fs/Path.html" title="class in org.apache.hadoop.fs">Path</a>&nbsp;path)
                          throws <a href="https://docs.oracle.com/javase/8/docs/api/java/io/IOException.html?is-external=true" title="class or interface in java.io">IOException</a></pre>
<div class="block">Set the source path to satisfy storage policy.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>path</code> - The source path referring to either a directory or a file.</dd>
<dt><span class="throwsLabel">Throws:</span></dt>
<dd><code><a href="https://docs.oracle.com/javase/8/docs/api/java/io/IOException.html?is-external=true" title="class or interface in java.io">IOException</a></code></dd>
</dl>
</li>
</ul>
<a name="setStoragePolicy-org.apache.hadoop.fs.Path-java.lang.String-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>setStoragePolicy</h4>
<pre>public&nbsp;void&nbsp;setStoragePolicy(<a href="../../../../org/apache/hadoop/fs/Path.html" title="class in org.apache.hadoop.fs">Path</a>&nbsp;path,
                             <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&nbsp;policyName)
                      throws <a href="https://docs.oracle.com/javase/8/docs/api/java/io/IOException.html?is-external=true" title="class or interface in java.io">IOException</a></pre>
<div class="block">Set the storage policy for a given file or directory.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>path</code> - file or directory path.</dd>
<dd><code>policyName</code> - the name of the target storage policy. The list
                   of supported Storage policies can be retrieved
                   via <a href="../../../../org/apache/hadoop/fs/FileContext.html#getAllStoragePolicies--"><code>getAllStoragePolicies()</code></a>.</dd>
<dt><span class="throwsLabel">Throws:</span></dt>
<dd><code><a href="https://docs.oracle.com/javase/8/docs/api/java/io/IOException.html?is-external=true" title="class or interface in java.io">IOException</a></code></dd>
</dl>
</li>
</ul>
<a name="unsetStoragePolicy-org.apache.hadoop.fs.Path-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>unsetStoragePolicy</h4>
<pre>public&nbsp;void&nbsp;unsetStoragePolicy(<a href="../../../../org/apache/hadoop/fs/Path.html" title="class in org.apache.hadoop.fs">Path</a>&nbsp;src)
                        throws <a href="https://docs.oracle.com/javase/8/docs/api/java/io/IOException.html?is-external=true" title="class or interface in java.io">IOException</a></pre>
<div class="block">Unset the storage policy set for a given file or directory.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>src</code> - file or directory path.</dd>
<dt><span class="throwsLabel">Throws:</span></dt>
<dd><code><a href="https://docs.oracle.com/javase/8/docs/api/java/io/IOException.html?is-external=true" title="class or interface in java.io">IOException</a></code></dd>
</dl>
</li>
</ul>
<a name="getStoragePolicy-org.apache.hadoop.fs.Path-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>getStoragePolicy</h4>
<pre>public&nbsp;<a href="../../../../org/apache/hadoop/fs/BlockStoragePolicySpi.html" title="interface in org.apache.hadoop.fs">BlockStoragePolicySpi</a>&nbsp;getStoragePolicy(<a href="../../../../org/apache/hadoop/fs/Path.html" title="class in org.apache.hadoop.fs">Path</a>&nbsp;path)
                                       throws <a href="https://docs.oracle.com/javase/8/docs/api/java/io/IOException.html?is-external=true" title="class or interface in java.io">IOException</a></pre>
<div class="block">Query the effective storage policy ID for the given file or directory.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>path</code> - file or directory path.</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>storage policy for give file.</dd>
<dt><span class="throwsLabel">Throws:</span></dt>
<dd><code><a href="https://docs.oracle.com/javase/8/docs/api/java/io/IOException.html?is-external=true" title="class or interface in java.io">IOException</a></code></dd>
</dl>
</li>
</ul>
<a name="getAllStoragePolicies--">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>getAllStoragePolicies</h4>
<pre>public&nbsp;<a href="https://docs.oracle.com/javase/8/docs/api/java/util/Collection.html?is-external=true" title="class or interface in java.util">Collection</a>&lt;? extends <a href="../../../../org/apache/hadoop/fs/BlockStoragePolicySpi.html" title="interface in org.apache.hadoop.fs">BlockStoragePolicySpi</a>&gt;&nbsp;getAllStoragePolicies()
                                                                  throws <a href="https://docs.oracle.com/javase/8/docs/api/java/io/IOException.html?is-external=true" title="class or interface in java.io">IOException</a></pre>
<div class="block">Retrieve all the storage policies supported by this file system.</div>
<dl>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>all storage policies supported by this filesystem.</dd>
<dt><span class="throwsLabel">Throws:</span></dt>
<dd><code><a href="https://docs.oracle.com/javase/8/docs/api/java/io/IOException.html?is-external=true" title="class or interface in java.io">IOException</a></code></dd>
</dl>
</li>
</ul>
<a name="openFile-org.apache.hadoop.fs.Path-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>openFile</h4>
<pre>@InterfaceStability.Unstable
public&nbsp;<a href="../../../../org/apache/hadoop/fs/FutureDataInputStreamBuilder.html" title="interface in org.apache.hadoop.fs">FutureDataInputStreamBuilder</a>&nbsp;openFile(<a href="../../../../org/apache/hadoop/fs/Path.html" title="class in org.apache.hadoop.fs">Path</a>&nbsp;path)
                                                                   throws <a href="https://docs.oracle.com/javase/8/docs/api/java/io/IOException.html?is-external=true" title="class or interface in java.io">IOException</a>,
                                                                          <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/UnsupportedOperationException.html?is-external=true" title="class or interface in java.lang">UnsupportedOperationException</a></pre>
<div class="block">Open a file for reading through a builder API.
 Ultimately calls <a href="../../../../org/apache/hadoop/fs/FileContext.html#open-org.apache.hadoop.fs.Path-int-"><code>open(Path, int)</code></a> unless a subclass
 executes the open command differently.

 The semantics of this call are therefore the same as that of
 <a href="../../../../org/apache/hadoop/fs/FileContext.html#open-org.apache.hadoop.fs.Path-int-"><code>open(Path, int)</code></a> with one special point: it is in
 <code>FSDataInputStreamBuilder.build()</code> in which the open operation
 takes place -it is there where all preconditions to the operation
 are checked.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>path</code> - file path</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>a FSDataInputStreamBuilder object to build the input stream</dd>
<dt><span class="throwsLabel">Throws:</span></dt>
<dd><code><a href="https://docs.oracle.com/javase/8/docs/api/java/io/IOException.html?is-external=true" title="class or interface in java.io">IOException</a></code> - if some early checks cause IO failures.</dd>
<dd><code><a href="https://docs.oracle.com/javase/8/docs/api/java/lang/UnsupportedOperationException.html?is-external=true" title="class or interface in java.lang">UnsupportedOperationException</a></code> - if support is checked early.</dd>
</dl>
</li>
</ul>
<a name="hasPathCapability-org.apache.hadoop.fs.Path-java.lang.String-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>hasPathCapability</h4>
<pre>public&nbsp;boolean&nbsp;hasPathCapability(<a href="../../../../org/apache/hadoop/fs/Path.html" title="class in org.apache.hadoop.fs">Path</a>&nbsp;path,
                                 <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&nbsp;capability)
                          throws <a href="https://docs.oracle.com/javase/8/docs/api/java/io/IOException.html?is-external=true" title="class or interface in java.io">IOException</a></pre>
<div class="block">Return the path capabilities of the bonded <code>AbstractFileSystem</code>.</div>
<dl>
<dt><span class="overrideSpecifyLabel">Specified by:</span></dt>
<dd><code><a href="../../../../org/apache/hadoop/fs/PathCapabilities.html#hasPathCapability-org.apache.hadoop.fs.Path-java.lang.String-">hasPathCapability</a></code>&nbsp;in interface&nbsp;<code><a href="../../../../org/apache/hadoop/fs/PathCapabilities.html" title="interface in org.apache.hadoop.fs">PathCapabilities</a></code></dd>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>path</code> - path to query the capability of.</dd>
<dd><code>capability</code> - string to query the stream support for.</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>true iff the capability is supported under that FS.</dd>
<dt><span class="throwsLabel">Throws:</span></dt>
<dd><code><a href="https://docs.oracle.com/javase/8/docs/api/java/io/IOException.html?is-external=true" title="class or interface in java.io">IOException</a></code> - path resolution or other IO failure</dd>
<dd><code><a href="https://docs.oracle.com/javase/8/docs/api/java/lang/IllegalArgumentException.html?is-external=true" title="class or interface in java.lang">IllegalArgumentException</a></code> - invalid arguments</dd>
</dl>
</li>
</ul>
<a name="getServerDefaults-org.apache.hadoop.fs.Path-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>getServerDefaults</h4>
<pre>public&nbsp;<a href="../../../../org/apache/hadoop/fs/FsServerDefaults.html" title="class in org.apache.hadoop.fs">FsServerDefaults</a>&nbsp;getServerDefaults(<a href="../../../../org/apache/hadoop/fs/Path.html" title="class in org.apache.hadoop.fs">Path</a>&nbsp;path)
                                   throws <a href="https://docs.oracle.com/javase/8/docs/api/java/io/IOException.html?is-external=true" title="class or interface in java.io">IOException</a></pre>
<div class="block">Return a set of server default configuration values based on path.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>path</code> - path to fetch server defaults</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>server default configuration values for path</dd>
<dt><span class="throwsLabel">Throws:</span></dt>
<dd><code><a href="https://docs.oracle.com/javase/8/docs/api/java/io/IOException.html?is-external=true" title="class or interface in java.io">IOException</a></code> - an I/O error occurred</dd>
</dl>
</li>
</ul>
<a name="createMultipartUploader-org.apache.hadoop.fs.Path-">
<!--   -->
</a>
<ul class="blockListLast">
<li class="blockList">
<h4>createMultipartUploader</h4>
<pre>@InterfaceStability.Unstable
public&nbsp;<a href="../../../../org/apache/hadoop/fs/MultipartUploaderBuilder.html" title="interface in org.apache.hadoop.fs">MultipartUploaderBuilder</a>&nbsp;createMultipartUploader(<a href="../../../../org/apache/hadoop/fs/Path.html" title="class in org.apache.hadoop.fs">Path</a>&nbsp;basePath)
                                                                              throws <a href="https://docs.oracle.com/javase/8/docs/api/java/io/IOException.html?is-external=true" title="class or interface in java.io">IOException</a></pre>
<div class="block">Create a multipart uploader.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>basePath</code> - file path under which all files are uploaded</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>a MultipartUploaderBuilder object to build the uploader</dd>
<dt><span class="throwsLabel">Throws:</span></dt>
<dd><code><a href="https://docs.oracle.com/javase/8/docs/api/java/io/IOException.html?is-external=true" title="class or interface in java.io">IOException</a></code> - if some early checks cause IO failures.</dd>
<dd><code><a href="https://docs.oracle.com/javase/8/docs/api/java/lang/UnsupportedOperationException.html?is-external=true" title="class or interface in java.lang">UnsupportedOperationException</a></code> - if support is checked early.</dd>
</dl>
</li>
</ul>
</li>
</ul>
</li>
</ul>
</div>
</div>
<!-- ========= END OF CLASS DATA ========= -->
<!-- ======= START OF BOTTOM NAVBAR ====== -->
<div class="bottomNav"><a name="navbar.bottom">
<!--   -->
</a>
<div class="skipNav"><a href="#skip.navbar.bottom" title="Skip navigation links">Skip navigation links</a></div>
<a name="navbar.bottom.firstrow">
<!--   -->
</a>
<ul class="navList" title="Navigation">
<li><a href="../../../../overview-summary.html">Overview</a></li>
<li><a href="package-summary.html">Package</a></li>
<li class="navBarCell1Rev">Class</li>
<li><a href="class-use/FileContext.html">Use</a></li>
<li><a href="package-tree.html">Tree</a></li>
<li><a href="../../../../deprecated-list.html">Deprecated</a></li>
<li><a href="../../../../index-all.html">Index</a></li>
<li><a href="../../../../help-doc.html">Help</a></li>
</ul>
</div>
<div class="subNav">
<ul class="navList">
<li><a href="../../../../org/apache/hadoop/fs/FileChecksum.html" title="class in org.apache.hadoop.fs"><span class="typeNameLink">Prev&nbsp;Class</span></a></li>
<li><a href="../../../../org/apache/hadoop/fs/FileContext.Util.html" title="class in org.apache.hadoop.fs"><span class="typeNameLink">Next&nbsp;Class</span></a></li>
</ul>
<ul class="navList">
<li><a href="../../../../index.html?org/apache/hadoop/fs/FileContext.html" target="_top">Frames</a></li>
<li><a href="FileContext.html" target="_top">No&nbsp;Frames</a></li>
</ul>
<ul class="navList" id="allclasses_navbar_bottom">
<li><a href="../../../../allclasses-noframe.html">All&nbsp;Classes</a></li>
</ul>
<div>
<script type="text/javascript"><!--
  allClassesLink = document.getElementById("allclasses_navbar_bottom");
  if(window==top) {
    allClassesLink.style.display = "block";
  }
  else {
    allClassesLink.style.display = "none";
  }
  //-->
</script>
</div>
<div>
<ul class="subNavList">
<li>Summary:&nbsp;</li>
<li><a href="#nested.class.summary">Nested</a>&nbsp;|&nbsp;</li>
<li><a href="#field.summary">Field</a>&nbsp;|&nbsp;</li>
<li>Constr&nbsp;|&nbsp;</li>
<li><a href="#method.summary">Method</a></li>
</ul>
<ul class="subNavList">
<li>Detail:&nbsp;</li>
<li><a href="#field.detail">Field</a>&nbsp;|&nbsp;</li>
<li>Constr&nbsp;|&nbsp;</li>
<li><a href="#method.detail">Method</a></li>
</ul>
</div>
<a name="skip.navbar.bottom">
<!--   -->
</a></div>
<!-- ======== END OF BOTTOM NAVBAR ======= -->
<p class="legalCopy"><small>Copyright &#169; 2008&#x2013;2021 <a href="https://www.apache.org">Apache Software Foundation</a>. All rights reserved.</small></p>
</body>
</html>
