001    /**
002     * Licensed to the Apache Software Foundation (ASF) under one
003     * or more contributor license agreements.  See the NOTICE file
004     * distributed with this work for additional information
005     * regarding copyright ownership.  The ASF licenses this file
006     * to you under the Apache License, Version 2.0 (the
007     * "License"); you may not use this file except in compliance
008     * with the License.  You may obtain a copy of the License at
009     *
010     *     http://www.apache.org/licenses/LICENSE-2.0
011     *
012     * Unless required by applicable law or agreed to in writing, software
013     * distributed under the License is distributed on an "AS IS" BASIS,
014     * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
015     * See the License for the specific language governing permissions and
016     * limitations under the License.
017     */
018    
019    package org.apache.hadoop.fs;
020    
021    import java.io.*;
022    import java.net.URI;
023    import java.net.URISyntaxException;
024    import java.util.EnumSet;
025    import java.util.List;
026    
027    import org.apache.hadoop.classification.InterfaceAudience;
028    import org.apache.hadoop.classification.InterfaceStability;
029    import org.apache.hadoop.conf.Configuration;
030    import org.apache.hadoop.fs.permission.FsPermission;
031    import org.apache.hadoop.security.Credentials;
032    import org.apache.hadoop.security.token.Token;
033    import org.apache.hadoop.util.Progressable;
034    
035    /****************************************************************
036     * A <code>FilterFileSystem</code> contains
037     * some other file system, which it uses as
038     * its  basic file system, possibly transforming
039     * the data along the way or providing  additional
040     * functionality. The class <code>FilterFileSystem</code>
041     * itself simply overrides all  methods of
042     * <code>FileSystem</code> with versions that
043     * pass all requests to the contained  file
044     * system. Subclasses of <code>FilterFileSystem</code>
045     * may further override some of  these methods
046     * and may also provide additional methods
047     * and fields.
048     *
049     *****************************************************************/
050    @InterfaceAudience.Public
051    @InterfaceStability.Stable
052    public class FilterFileSystem extends FileSystem {
053      
054      protected FileSystem fs;
055      private String swapScheme;
056      
057      /*
058       * so that extending classes can define it
059       */
060      public FilterFileSystem() {
061      }
062      
063      public FilterFileSystem(FileSystem fs) {
064        this.fs = fs;
065        this.statistics = fs.statistics;
066      }
067    
068      /**
069       * Get the raw file system 
070       * @return FileSystem being filtered
071       */
072      public FileSystem getRawFileSystem() {
073        return fs;
074      }
075    
076      /** Called after a new FileSystem instance is constructed.
077       * @param name a uri whose authority section names the host, port, etc.
078       *   for this FileSystem
079       * @param conf the configuration
080       */
081      public void initialize(URI name, Configuration conf) throws IOException {
082        super.initialize(name, conf);
083        // this is less than ideal, but existing filesystems sometimes neglect
084        // to initialize the embedded filesystem
085        if (fs.getConf() == null) {
086          fs.initialize(name, conf);
087        }
088        String scheme = name.getScheme();
089        if (!scheme.equals(fs.getUri().getScheme())) {
090          swapScheme = scheme;
091        }
092      }
093    
094      /** Returns a URI whose scheme and authority identify this FileSystem.*/
095      public URI getUri() {
096        return fs.getUri();
097      }
098    
099      /**
100       * Returns a qualified URI whose scheme and authority identify this
101       * FileSystem.
102       */
103      @Override
104      protected URI getCanonicalUri() {
105        return fs.getCanonicalUri();
106      }
107      
108      /** Make sure that a path specifies a FileSystem. */
109      public Path makeQualified(Path path) {
110        Path fqPath = fs.makeQualified(path);
111        // swap in our scheme if the filtered fs is using a different scheme
112        if (swapScheme != null) {
113          try {
114            // NOTE: should deal with authority, but too much other stuff is broken 
115            fqPath = new Path(
116                new URI(swapScheme, fqPath.toUri().getSchemeSpecificPart(), null)
117            );
118          } catch (URISyntaxException e) {
119            throw new IllegalArgumentException(e);
120          }
121        }
122        return fqPath;
123      }
124      
125      ///////////////////////////////////////////////////////////////
126      // FileSystem
127      ///////////////////////////////////////////////////////////////
128    
129      /** Check that a Path belongs to this FileSystem. */
130      protected void checkPath(Path path) {
131        fs.checkPath(path);
132      }
133    
134      public BlockLocation[] getFileBlockLocations(FileStatus file, long start,
135        long len) throws IOException {
136          return fs.getFileBlockLocations(file, start, len);
137      }
138    
139      @Override
140      public Path resolvePath(final Path p) throws IOException {
141        return fs.resolvePath(p);
142      }
143      /**
144       * Opens an FSDataInputStream at the indicated Path.
145       * @param f the file name to open
146       * @param bufferSize the size of the buffer to be used.
147       */
148      public FSDataInputStream open(Path f, int bufferSize) throws IOException {
149        return fs.open(f, bufferSize);
150      }
151    
152      /** {@inheritDoc} */
153      public FSDataOutputStream append(Path f, int bufferSize,
154          Progressable progress) throws IOException {
155        return fs.append(f, bufferSize, progress);
156      }
157    
158      /** {@inheritDoc} */
159      @Override
160      public FSDataOutputStream create(Path f, FsPermission permission,
161          boolean overwrite, int bufferSize, short replication, long blockSize,
162          Progressable progress) throws IOException {
163        return fs.create(f, permission,
164            overwrite, bufferSize, replication, blockSize, progress);
165      }
166    
167      /**
168       * Set replication for an existing file.
169       * 
170       * @param src file name
171       * @param replication new replication
172       * @throws IOException
173       * @return true if successful;
174       *         false if file does not exist or is a directory
175       */
176      public boolean setReplication(Path src, short replication) throws IOException {
177        return fs.setReplication(src, replication);
178      }
179      
180      /**
181       * Renames Path src to Path dst.  Can take place on local fs
182       * or remote DFS.
183       */
184      public boolean rename(Path src, Path dst) throws IOException {
185        return fs.rename(src, dst);
186      }
187      
188      /** Delete a file */
189      public boolean delete(Path f, boolean recursive) throws IOException {
190        return fs.delete(f, recursive);
191      }
192      
193      /**
194       * Mark a path to be deleted when FileSystem is closed.
195       * When the JVM shuts down,
196       * all FileSystem objects will be closed automatically.
197       * Then,
198       * the marked path will be deleted as a result of closing the FileSystem.
199       *
200       * The path has to exist in the file system.
201       * 
202       * @param f the path to delete.
203       * @return  true if deleteOnExit is successful, otherwise false.
204       * @throws IOException
205       */
206      public boolean deleteOnExit(Path f) throws IOException {
207        return fs.deleteOnExit(f);
208      }    
209    
210      /** List files in a directory. */
211      public FileStatus[] listStatus(Path f) throws IOException {
212        return fs.listStatus(f);
213      }
214    
215      /**
216       * {@inheritDoc}
217       */
218      @Override
219      public RemoteIterator<Path> listCorruptFileBlocks(Path path)
220        throws IOException {
221        return fs.listCorruptFileBlocks(path);
222      }
223    
224      /** List files and its block locations in a directory. */
225      public RemoteIterator<LocatedFileStatus> listLocatedStatus(Path f)
226      throws IOException {
227        return fs.listLocatedStatus(f);
228      }
229      
230      public Path getHomeDirectory() {
231        return fs.getHomeDirectory();
232      }
233    
234    
235      /**
236       * Set the current working directory for the given file system. All relative
237       * paths will be resolved relative to it.
238       * 
239       * @param newDir
240       */
241      public void setWorkingDirectory(Path newDir) {
242        fs.setWorkingDirectory(newDir);
243      }
244      
245      /**
246       * Get the current working directory for the given file system
247       * 
248       * @return the directory pathname
249       */
250      public Path getWorkingDirectory() {
251        return fs.getWorkingDirectory();
252      }
253      
254      protected Path getInitialWorkingDirectory() {
255        return fs.getInitialWorkingDirectory();
256      }
257      
258      /** {@inheritDoc} */
259      @Override
260      public FsStatus getStatus(Path p) throws IOException {
261        return fs.getStatus(p);
262      }
263      
264      /** {@inheritDoc} */
265      @Override
266      public boolean mkdirs(Path f, FsPermission permission) throws IOException {
267        return fs.mkdirs(f, permission);
268      }
269    
270      /**
271       * The src file is on the local disk.  Add it to FS at
272       * the given dst name.
273       * delSrc indicates if the source should be removed
274       */
275      public void copyFromLocalFile(boolean delSrc, Path src, Path dst)
276        throws IOException {
277        fs.copyFromLocalFile(delSrc, src, dst);
278      }
279      
280      /**
281       * The src files are on the local disk.  Add it to FS at
282       * the given dst name.
283       * delSrc indicates if the source should be removed
284       */
285      public void copyFromLocalFile(boolean delSrc, boolean overwrite, 
286                                    Path[] srcs, Path dst)
287        throws IOException {
288        fs.copyFromLocalFile(delSrc, overwrite, srcs, dst);
289      }
290      
291      /**
292       * The src file is on the local disk.  Add it to FS at
293       * the given dst name.
294       * delSrc indicates if the source should be removed
295       */
296      public void copyFromLocalFile(boolean delSrc, boolean overwrite, 
297                                    Path src, Path dst)
298        throws IOException {
299        fs.copyFromLocalFile(delSrc, overwrite, src, dst);
300      }
301    
302      /**
303       * The src file is under FS, and the dst is on the local disk.
304       * Copy it from FS control to the local dst name.
305       * delSrc indicates if the src will be removed or not.
306       */   
307      public void copyToLocalFile(boolean delSrc, Path src, Path dst)
308        throws IOException {
309        fs.copyToLocalFile(delSrc, src, dst);
310      }
311      
312      /**
313       * Returns a local File that the user can write output to.  The caller
314       * provides both the eventual FS target name and the local working
315       * file.  If the FS is local, we write directly into the target.  If
316       * the FS is remote, we write into the tmp local area.
317       */
318      public Path startLocalOutput(Path fsOutputFile, Path tmpLocalFile)
319        throws IOException {
320        return fs.startLocalOutput(fsOutputFile, tmpLocalFile);
321      }
322    
323      /**
324       * Called when we're all done writing to the target.  A local FS will
325       * do nothing, because we've written to exactly the right place.  A remote
326       * FS will copy the contents of tmpLocalFile to the correct target at
327       * fsOutputFile.
328       */
329      public void completeLocalOutput(Path fsOutputFile, Path tmpLocalFile)
330        throws IOException {
331        fs.completeLocalOutput(fsOutputFile, tmpLocalFile);
332      }
333    
334      /** Return the total size of all files in the filesystem.*/
335      public long getUsed() throws IOException{
336        return fs.getUsed();
337      }
338      
339      /** Return the number of bytes that large input files should be optimally
340       * be split into to minimize i/o time. */
341      public long getDefaultBlockSize() {
342        return fs.getDefaultBlockSize();
343      }
344      
345      /**
346       * Get the default replication.
347       */
348      public short getDefaultReplication() {
349        return fs.getDefaultReplication();
350      }
351    
352      /**
353       * Get file status.
354       */
355      public FileStatus getFileStatus(Path f) throws IOException {
356        return fs.getFileStatus(f);
357      }
358    
359      /** {@inheritDoc} */
360      public FileChecksum getFileChecksum(Path f) throws IOException {
361        return fs.getFileChecksum(f);
362      }
363      
364      /** {@inheritDoc} */
365      public void setVerifyChecksum(boolean verifyChecksum) {
366        fs.setVerifyChecksum(verifyChecksum);
367      }
368    
369      @Override
370      public Configuration getConf() {
371        return fs.getConf();
372      }
373      
374      @Override
375      public void close() throws IOException {
376        super.close();
377        fs.close();
378      }
379    
380      /** {@inheritDoc} */
381      @Override
382      public void setOwner(Path p, String username, String groupname
383          ) throws IOException {
384        fs.setOwner(p, username, groupname);
385      }
386    
387      /** {@inheritDoc} */
388      @Override
389      public void setTimes(Path p, long mtime, long atime
390          ) throws IOException {
391        fs.setTimes(p, mtime, atime);
392      }
393    
394      /** {@inheritDoc} */
395      @Override
396      public void setPermission(Path p, FsPermission permission
397          ) throws IOException {
398        fs.setPermission(p, permission);
399      }
400    
401      @Override
402      protected FSDataOutputStream primitiveCreate(Path f,
403          FsPermission absolutePermission, EnumSet<CreateFlag> flag,
404          int bufferSize, short replication, long blockSize, Progressable progress, int bytesPerChecksum)
405          throws IOException {
406        return fs.primitiveCreate(f, absolutePermission, flag,
407            bufferSize, replication, blockSize, progress, bytesPerChecksum);
408      }
409    
410      @Override
411      @SuppressWarnings("deprecation")
412      protected boolean primitiveMkdir(Path f, FsPermission abdolutePermission)
413          throws IOException {
414        return fs.primitiveMkdir(f, abdolutePermission);
415      }
416      
417      @Override // FileSystem
418      public String getCanonicalServiceName() {
419        return fs.getCanonicalServiceName();
420      }
421      
422      @Override // FileSystem
423      @SuppressWarnings("deprecation")
424      public Token<?> getDelegationToken(String renewer) throws IOException {
425        return fs.getDelegationToken(renewer);
426      }
427      
428      @Override // FileSystem
429      public List<Token<?>> getDelegationTokens(String renewer) throws IOException {
430        return fs.getDelegationTokens(renewer);
431      }
432      
433      @Override
434      // FileSystem
435      public List<Token<?>> getDelegationTokens(String renewer,
436          Credentials credentials) throws IOException {
437        return fs.getDelegationTokens(renewer, credentials);
438      }
439    }