Hadoop源码阅读-HDFS-day2

  1 /**
  2  * The FileContext class provides an interface to the application writer for
  3  * using the Hadoop file system.
  4  * It provides a set of methods for the usual operation: create, open, 
  5  * list, etc 
  6  * 
  7  * <p>
  8  * <b> *** Path Names *** </b>
  9  * <p>
 10  * 
 11  * The Hadoop file system supports a URI name space and URI names.
 12  * It offers a forest of file systems that can be referenced using fully
 13  * qualified URIs.
 14  * Two common Hadoop file systems implementations are
 15  * <ul>
 16  * <li> the local file system: file:///path
 17  * <li> the hdfs file system hdfs://nnAddress:nnPort/path
 18  * </ul>
 19  * 
 20  * While URI names are very flexible, it requires knowing the name or address
 21  * of the server. For convenience one often wants to access the default system
 22  * in one‘s environment without knowing its name/address. This has an
 23  * additional benefit that it allows one to change one‘s default fs
 24  *  (e.g. admin moves application from cluster1 to cluster2).
 25  * <p>
 26  * 
 27  * To facilitate this, Hadoop supports a notion of a default file system.
 28  * The user can set his default file system, although this is
 29  * typically set up for you in your environment via your default config.
 30  * A default file system implies a default scheme and authority; slash-relative
 31  * names (such as /for/bar) are resolved relative to that default FS.
 32  * Similarly a user can also have working-directory-relative names (i.e. names
 33  * not starting with a slash). While the working directory is generally in the
 34  * same default FS, the wd can be in a different FS.
 35  * <p>
 36  *  Hence Hadoop path names can be one of:
 37  *  <ul>
 38  *  <li> fully qualified URI: scheme://authority/path
 39  *  <li> slash relative names: /path relative to the default file system
 40  *  <li> wd-relative names: path  relative to the working dir
 41  *  </ul>   
 42  *  Relative paths with scheme (scheme:foo/bar) are illegal.
 43  *  
 44  *  <p>
 45  *  <b>****The Role of the FileContext and configuration defaults****</b>
 46  *  <p>
 47  *  The FileContext provides file namespace context for resolving file names;
 48  *  it also contains the umask for permissions, In that sense it is like the
 49  *  per-process file-related state in Unix system.
 50  *  These two properties
 51  *  <ul> 
 52  *  <li> default file system i.e your slash)
 53  *  <li> umask
 54  *  </ul>
 55  *  in general, are obtained from the default configuration file
 56  *  in your environment,  (@see {@link Configuration}).
 57  *  
 58  *  No other configuration parameters are obtained from the default config as 
 59  *  far as the file context layer is concerned. All file system instances
 60  *  (i.e. deployments of file systems) have default properties; we call these
 61  *  server side (SS) defaults. Operation like create allow one to select many 
 62  *  properties: either pass them in as explicit parameters or use
 63  *  the SS properties.
 64  *  <p>
 65  *  The file system related SS defaults are
 66  *  <ul>
 67  *  <li> the home directory (default is "/user/userName")
 68  *  <li> the initial wd (only for local fs)
 69  *  <li> replication factor
 70  *  <li> block size
 71  *  <li> buffer size
 72  *  <li> encryptDataTransfer 
 73  *  <li> checksum option. (checksumType and  bytesPerChecksum)
 74  *  </ul>
 75  *
 76  * <p>
 77  * <b> *** Usage Model for the FileContext class *** </b>
 78  * <p>
 79  * Example 1: use the default config read from the $HADOOP_CONFIG/core.xml.
 80  *   Unspecified values come from core-defaults.xml in the release jar.
 81  *  <ul>  
 82  *  <li> myFContext = FileContext.getFileContext(); // uses the default config
 83  *                                                // which has your default FS 
 84  *  <li>  myFContext.create(path, ...);
 85  *  <li>  myFContext.setWorkingDir(path)
 86  *  <li>  myFContext.open (path, ...);  
 87  *  </ul>  
 88  * Example 2: Get a FileContext with a specific URI as the default FS
 89  *  <ul>  
 90  *  <li> myFContext = FileContext.getFileContext(URI)
 91  *  <li> myFContext.create(path, ...);
 92  *   ...
 93  * </ul> 
 94  * Example 3: FileContext with local file system as the default
 95  *  <ul> 
 96  *  <li> myFContext = FileContext.getLocalFSFileContext()
 97  *  <li> myFContext.create(path, ...);
 98  *  <li> ...
 99  *  </ul> 
100  * Example 4: Use a specific config, ignoring $HADOOP_CONFIG
101  *  Generally you should not need use a config unless you are doing
102  *   <ul> 
103  *   <li> configX = someConfigSomeOnePassedToYou.
104  *   <li> myFContext = getFileContext(configX); // configX is not changed,
105  *                                              // is passed down 
106  *   <li> myFContext.create(path, ...);
107  *   <li>...
108  *  </ul>                                          
109  *    
110  */
111 
112 @InterfaceAudience.Public
113 @InterfaceStability.Evolving /*Evolving for a release,to be changed to Stable */
114 public class FileContext {

 1 /**
 2    * Create or overwrite file on indicated path and returns an output stream for
 3    * writing into the file.
 4    * 
 5    * @param f the file name to open
 6    * @param createFlag gives the semantics of create; see {@link CreateFlag}
 7    * @param opts file creation options; see {@link Options.CreateOpts}.
 8    *          <ul>
 9    *          <li>Progress - to report progress on the operation - default null
10    *          <li>Permission - umask is applied against permisssion: default is
11    *          FsPermissions:getDefault()
12    * 
13    *          <li>CreateParent - create missing parent path; default is to not
14    *          to create parents
15    *          <li>The defaults for the following are SS defaults of the file
16    *          server implementing the target path. Not all parameters make sense
17    *          for all kinds of file system - eg. localFS ignores Blocksize,
18    *          replication, checksum
19    *          <ul>
20    *          <li>BufferSize - buffersize used in FSDataOutputStream
21    *          <li>Blocksize - block size for file blocks
22    *          <li>ReplicationFactor - replication for blocks
23    *          <li>ChecksumParam - Checksum parameters. server default is used
24    *          if not specified.
25    *          </ul>
26    *          </ul>
27    * 
28    * @return {@link FSDataOutputStream} for created file
29    * 
30    * @throws AccessControlException If access is denied
31    * @throws FileAlreadyExistsException If file <code>f</code> already exists
32    * @throws FileNotFoundException If parent of <code>f</code> does not exist
33    *           and <code>createParent</code> is false
34    * @throws ParentNotDirectoryException If parent of <code>f</code> is not a
35    *           directory.
36    * @throws UnsupportedFileSystemException If file system for <code>f</code> is
37    *           not supported
38    * @throws IOException If an I/O error occurred
39    * 
40    * Exceptions applicable to file systems accessed over RPC:
41    * @throws RpcClientException If an exception occurred in the RPC client
42    * @throws RpcServerException If an exception occurred in the RPC server
43    * @throws UnexpectedServerException If server implementation throws
44    *           undeclared exception to RPC server
45    * 
46    * RuntimeExceptions:
47    * @throws InvalidPathException If path <code>f</code> is not valid
48    */

 1 /**
 2    * Generic helper function overridden on instantiation to perform a
 3    * specific operation on the given file system using the given path
 4    * which may result in an UnresolvedLinkException.
 5    * @param fs AbstractFileSystem to perform the operation on.
 6    * @param p Path given the file system.
 7    * @return Generic type determined by the specific implementation.
 8    * @throws UnresolvedLinkException If symbolic link <code>path</code> could
 9    *           not be resolved
10    * @throws IOException an I/O error occurred
11    */
12   abstract public T next(final AbstractFileSystem fs, final Path p)
13       throws IOException, UnresolvedLinkException;
14 
15 
16 
17 
18 /**
19    * Performs the operation specified by the next function, calling it
20    * repeatedly until all symlinks in the given path are resolved.
21    * @param fc FileContext used to access file systems.
22    * @param path The path to resolve symlinks on.
23    * @return Generic type determined by the implementation of next.
24    * @throws IOException
25    */
26   public T resolve(final FileContext fc, final Path path) throws IOException {
27     int count = 0;
28     T in = null;
29     Path p = path;
30     // NB: More than one AbstractFileSystem can match a scheme, eg 
31     // "file" resolves to LocalFs but could have come by RawLocalFs.
32     AbstractFileSystem fs = fc.getFSofPath(p);
33 
34     // Loop until all symlinks are resolved or the limit is reached
35     for (boolean isLink = true; isLink;) {
36       try {
37         in = next(fs, p);
38         isLink = false;
39       } catch (UnresolvedLinkException e) {
40         if (!fc.resolveSymlinks) {
41           throw new IOException("Path " + path + " contains a symlink"
42               + " and symlink resolution is disabled ("
43               + CommonConfigurationKeys.FS_CLIENT_RESOLVE_REMOTE_SYMLINKS_KEY + ").", e);
44         }
45         if (!FileSystem.areSymlinksEnabled()) {
46           throw new IOException("Symlink resolution is disabled in"
47               + " this version of Hadoop.");
48         }
49         if (count++ > FsConstants.MAX_PATH_LINKS) {
50           throw new IOException("Possible cyclic loop while " +
51                                 "following symbolic link " + path);
52         }
53         // Resolve the first unresolved path component
54         p = qualifySymlinkTarget(fs.getUri(), p, fs.getLinkTarget(p));
55         fs = fc.getFSofPath(p);
56       }
57     }
58     return in;
59   }