@InterfaceAudience.Private

 @InterfaceStability.Evolving

 public class Hdfs extends AbstractFileSystem {

   DFSClient dfs;

   final CryptoCodec factory;

   private boolean verifyChecksum = true;

   static {

     HdfsConfiguration.init();

   }

   /**

    * This constructor has the signature needed by

    * {@link AbstractFileSystem#createFileSystem(URI, Configuration)}

    *

    * @param theUri which must be that of Hdfs

    * @param conf configuration

    * @throws IOException

    */

   Hdfs(final URI theUri, final Configuration conf) throws IOException, URISyntaxException {

     super(theUri, HdfsConstants.HDFS_URI_SCHEME, true, NameNode.DEFAULT_PORT);

     if (!theUri.getScheme().equalsIgnoreCase(HdfsConstants.HDFS_URI_SCHEME)) {

       throw new IllegalArgumentException("Passed URI's scheme is not for Hdfs");

     }

     String host = theUri.getHost();

     if (host == null) {

       throw new IOException("Incomplete HDFS URI, no host: " + theUri);

     }

     this.dfs = new DFSClient(theUri, conf, getStatistics());

     this.factory = CryptoCodec.getInstance(conf);

   }

/**

   * This method is here so that when invoked, HdfsConfiguration is class-loaded if

   * it hasn't already been previously loaded.  Upon loading the class, the static

   * initializer block above will be executed to add the deprecated keys and to add

   * the default resources.   It is safe for this method to be called multiple times

   * as the static initializer block will only get invoked once.

   *

   * This replaces the previously, dangerous practice of other classes calling

   * Configuration.addDefaultResource("hdfs-default.xml") directly without loading

   * HdfsConfiguration class first, thereby skipping the key deprecation

   */

  public static void init() {

  }

static {

    addDeprecatedKeys();

    // adds the default resources

    Configuration.addDefaultResource("hdfs-default.xml");

    Configuration.addDefaultResource("hdfs-site.xml");

  }

/**

 * This class provides an interface for implementors of a Hadoop file system

 * (analogous to the VFS of Unix). Applications do not access this class;

 * instead they access files across all file systems using {@link FileContext}.

 *

 * Pathnames passed to AbstractFileSystem can be fully qualified URI that

 * matches the "this" file system (ie same scheme and authority)

 * or a Slash-relative name that is assumed to be relative

 * to the root of the "this" file system .

 */

@InterfaceAudience.Public

@InterfaceStability.Evolving /*Evolving for a release,to be changed to Stable */

public abstract class AbstractFileSystem {

/**

   * Constructor to be called by subclasses.

   *

   * @param uri for this file system.

   * @param supportedScheme the scheme supported by the implementor

   * @param authorityNeeded if true then theURI must have authority, if false

   *          then the URI must have null authority.

   *

   * @throws URISyntaxException <code>uri</code> has syntax error

   */

  public AbstractFileSystem(final URI uri, final String supportedScheme,

      final boolean authorityNeeded, final int defaultPort)

      throws URISyntaxException {

    myUri = getUri(uri, supportedScheme, authorityNeeded, defaultPort);

    statistics = getStatistics(uri);

  }

/**

   * Get the URI for the file system based on the given URI. The path, query

   * part of the given URI is stripped out and default file system port is used

   * to form the URI.

   *

   * @param uri FileSystem URI.

   * @param authorityNeeded if true authority cannot be null in the URI. If

   *          false authority must be null.

   * @param defaultPort default port to use if port is not specified in the URI.

   *

   * @return URI of the file system

   *

   * @throws URISyntaxException <code>uri</code> has syntax error

   */

  private URI getUri(URI uri, String supportedScheme,

      boolean authorityNeeded, int defaultPort) throws URISyntaxException {

    checkScheme(uri, supportedScheme);

    // A file system implementation that requires authority must always

    // specify default port

    if (defaultPort < 0 && authorityNeeded) {

      throw new HadoopIllegalArgumentException(

          "FileSystem implementation error -  default port " + defaultPort

              + " is not valid");

    }

    String authority = uri.getAuthority();

    if (authority == null) {

       if (authorityNeeded) {

         throw new HadoopIllegalArgumentException("Uri without authority: " + uri);

       } else {

         return new URI(supportedScheme + ":///");

       }

    }

    // authority is non null  - AuthorityNeeded may be true or false.

    int port = uri.getPort();

    port = (port == -1 ? defaultPort : port);

    if (port == -1) { // no port supplied and default port is not specified

      return new URI(supportedScheme, authority, "/", null);

    }

    return new URI(supportedScheme + "://" + uri.getHost() + ":" + port);

  }