FilterFileSystem.java
上传用户:quxuerui
上传日期:2018-01-08
资源大小:41811k
文件大小:8k
源码类别:

网格计算

开发平台:

Java

  1. /**
  2.  * Licensed to the Apache Software Foundation (ASF) under one
  3.  * or more contributor license agreements.  See the NOTICE file
  4.  * distributed with this work for additional information
  5.  * regarding copyright ownership.  The ASF licenses this file
  6.  * to you under the Apache License, Version 2.0 (the
  7.  * "License"); you may not use this file except in compliance
  8.  * with the License.  You may obtain a copy of the License at
  9.  *
  10.  *     http://www.apache.org/licenses/LICENSE-2.0
  11.  *
  12.  * Unless required by applicable law or agreed to in writing, software
  13.  * distributed under the License is distributed on an "AS IS" BASIS,
  14.  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  15.  * See the License for the specific language governing permissions and
  16.  * limitations under the License.
  17.  */
  18. package org.apache.hadoop.fs;
  19. import java.io.*;
  20. import java.net.URI;
  21. import org.apache.hadoop.conf.Configuration;
  22. import org.apache.hadoop.fs.permission.FsPermission;
  23. import org.apache.hadoop.util.Progressable;
  24. /****************************************************************
  25.  * A <code>FilterFileSystem</code> contains
  26.  * some other file system, which it uses as
  27.  * its  basic file system, possibly transforming
  28.  * the data along the way or providing  additional
  29.  * functionality. The class <code>FilterFileSystem</code>
  30.  * itself simply overrides all  methods of
  31.  * <code>FileSystem</code> with versions that
  32.  * pass all requests to the contained  file
  33.  * system. Subclasses of <code>FilterFileSystem</code>
  34.  * may further override some of  these methods
  35.  * and may also provide additional methods
  36.  * and fields.
  37.  *
  38.  *****************************************************************/
  39. public class FilterFileSystem extends FileSystem {
  40.   
  41.   protected FileSystem fs;
  42.   
  43.   /*
  44.    * so that extending classes can define it
  45.    */
  46.   public FilterFileSystem() {
  47.   }
  48.   
  49.   public FilterFileSystem(FileSystem fs) {
  50.     this.fs = fs;
  51.     this.statistics = fs.statistics;
  52.   }
  53.   /** Called after a new FileSystem instance is constructed.
  54.    * @param name a uri whose authority section names the host, port, etc.
  55.    *   for this FileSystem
  56.    * @param conf the configuration
  57.    */
  58.   public void initialize(URI name, Configuration conf) throws IOException {
  59.     fs.initialize(name, conf);
  60.   }
  61.   /** Returns a URI whose scheme and authority identify this FileSystem.*/
  62.   public URI getUri() {
  63.     return fs.getUri();
  64.   }
  65.   /** @deprecated call #getUri() instead.*/
  66.   public String getName() {
  67.     return fs.getName();
  68.   }
  69.   /** Make sure that a path specifies a FileSystem. */
  70.   public Path makeQualified(Path path) {
  71.     return fs.makeQualified(path);
  72.   }
  73.   
  74.   ///////////////////////////////////////////////////////////////
  75.   // FileSystem
  76.   ///////////////////////////////////////////////////////////////
  77.   /** Check that a Path belongs to this FileSystem. */
  78.   protected void checkPath(Path path) {
  79.     fs.checkPath(path);
  80.   }
  81.   public BlockLocation[] getFileBlockLocations(FileStatus file, long start,
  82.     long len) throws IOException {
  83.       return fs.getFileBlockLocations(file, start, len);
  84.   }
  85.   
  86.   /**
  87.    * Opens an FSDataInputStream at the indicated Path.
  88.    * @param f the file name to open
  89.    * @param bufferSize the size of the buffer to be used.
  90.    */
  91.   public FSDataInputStream open(Path f, int bufferSize) throws IOException {
  92.     return fs.open(f, bufferSize);
  93.   }
  94.   /** {@inheritDoc} */
  95.   public FSDataOutputStream append(Path f, int bufferSize,
  96.       Progressable progress) throws IOException {
  97.     return fs.append(f, bufferSize, progress);
  98.   }
  99.   /** {@inheritDoc} */
  100.   @Override
  101.   public FSDataOutputStream create(Path f, FsPermission permission,
  102.       boolean overwrite, int bufferSize, short replication, long blockSize,
  103.       Progressable progress) throws IOException {
  104.     return fs.create(f, permission,
  105.         overwrite, bufferSize, replication, blockSize, progress);
  106.   }
  107.   /**
  108.    * Set replication for an existing file.
  109.    * 
  110.    * @param src file name
  111.    * @param replication new replication
  112.    * @throws IOException
  113.    * @return true if successful;
  114.    *         false if file does not exist or is a directory
  115.    */
  116.   public boolean setReplication(Path src, short replication) throws IOException {
  117.     return fs.setReplication(src, replication);
  118.   }
  119.   
  120.   /**
  121.    * Renames Path src to Path dst.  Can take place on local fs
  122.    * or remote DFS.
  123.    */
  124.   public boolean rename(Path src, Path dst) throws IOException {
  125.     return fs.rename(src, dst);
  126.   }
  127.   
  128.   /** Delete a file */@Deprecated
  129.   public boolean delete(Path f) throws IOException {
  130.     return delete(f, true);
  131.   }
  132.   
  133.   /** Delete a file */
  134.   public boolean delete(Path f, boolean recursive) throws IOException {
  135.     return fs.delete(f, recursive);
  136.   }
  137.   
  138.   /** List files in a directory. */
  139.   public FileStatus[] listStatus(Path f) throws IOException {
  140.     return fs.listStatus(f);
  141.   }
  142.   
  143.   public Path getHomeDirectory() {
  144.     return fs.getHomeDirectory();
  145.   }
  146.   /**
  147.    * Set the current working directory for the given file system. All relative
  148.    * paths will be resolved relative to it.
  149.    * 
  150.    * @param newDir
  151.    */
  152.   public void setWorkingDirectory(Path newDir) {
  153.     fs.setWorkingDirectory(newDir);
  154.   }
  155.   
  156.   /**
  157.    * Get the current working directory for the given file system
  158.    * 
  159.    * @return the directory pathname
  160.    */
  161.   public Path getWorkingDirectory() {
  162.     return fs.getWorkingDirectory();
  163.   }
  164.   
  165.   /** {@inheritDoc} */
  166.   @Override
  167.   public boolean mkdirs(Path f, FsPermission permission) throws IOException {
  168.     return fs.mkdirs(f, permission);
  169.   }
  170.   /**
  171.    * The src file is on the local disk.  Add it to FS at
  172.    * the given dst name.
  173.    * delSrc indicates if the source should be removed
  174.    */
  175.   public void copyFromLocalFile(boolean delSrc, Path src, Path dst)
  176.     throws IOException {
  177.     fs.copyFromLocalFile(delSrc, src, dst);
  178.   }
  179.   
  180.   /**
  181.    * The src file is under FS, and the dst is on the local disk.
  182.    * Copy it from FS control to the local dst name.
  183.    * delSrc indicates if the src will be removed or not.
  184.    */   
  185.   public void copyToLocalFile(boolean delSrc, Path src, Path dst)
  186.     throws IOException {
  187.     fs.copyToLocalFile(delSrc, src, dst);
  188.   }
  189.   
  190.   /**
  191.    * Returns a local File that the user can write output to.  The caller
  192.    * provides both the eventual FS target name and the local working
  193.    * file.  If the FS is local, we write directly into the target.  If
  194.    * the FS is remote, we write into the tmp local area.
  195.    */
  196.   public Path startLocalOutput(Path fsOutputFile, Path tmpLocalFile)
  197.     throws IOException {
  198.     return fs.startLocalOutput(fsOutputFile, tmpLocalFile);
  199.   }
  200.   /**
  201.    * Called when we're all done writing to the target.  A local FS will
  202.    * do nothing, because we've written to exactly the right place.  A remote
  203.    * FS will copy the contents of tmpLocalFile to the correct target at
  204.    * fsOutputFile.
  205.    */
  206.   public void completeLocalOutput(Path fsOutputFile, Path tmpLocalFile)
  207.     throws IOException {
  208.     fs.completeLocalOutput(fsOutputFile, tmpLocalFile);
  209.   }
  210.   /** Return the number of bytes that large input files should be optimally
  211.    * be split into to minimize i/o time. */
  212.   public long getDefaultBlockSize() {
  213.     return fs.getDefaultBlockSize();
  214.   }
  215.   
  216.   /**
  217.    * Get the default replication.
  218.    */
  219.   public short getDefaultReplication() {
  220.     return fs.getDefaultReplication();
  221.   }
  222.   /**
  223.    * Get file status.
  224.    */
  225.   public FileStatus getFileStatus(Path f) throws IOException {
  226.     return fs.getFileStatus(f);
  227.   }
  228.   /** {@inheritDoc} */
  229.   public FileChecksum getFileChecksum(Path f) throws IOException {
  230.     return fs.getFileChecksum(f);
  231.   }
  232.   
  233.   /** {@inheritDoc} */
  234.   public void setVerifyChecksum(boolean verifyChecksum) {
  235.     fs.setVerifyChecksum(verifyChecksum);
  236.   }
  237.   @Override
  238.   public Configuration getConf() {
  239.     return fs.getConf();
  240.   }
  241.   
  242.   @Override
  243.   public void close() throws IOException {
  244.     super.close();
  245.     fs.close();
  246.   }
  247.   /** {@inheritDoc} */
  248.   @Override
  249.   public void setOwner(Path p, String username, String groupname
  250.       ) throws IOException {
  251.     fs.setOwner(p, username, groupname);
  252.   }
  253.   /** {@inheritDoc} */
  254.   @Override
  255.   public void setPermission(Path p, FsPermission permission
  256.       ) throws IOException {
  257.     fs.setPermission(p, permission);
  258.   }
  259. }