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

网格计算

开发平台:

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.text.*;
  20. import java.io.*;
  21. import java.util.Date;
  22. import org.apache.commons.logging.*;
  23. import org.apache.hadoop.conf.*;
  24. import org.apache.hadoop.fs.permission.*;
  25. import org.apache.hadoop.util.StringUtils;
  26. /** Provides a <i>trash</i> feature.  Files are moved to a user's trash
  27.  * directory, a subdirectory of their home directory named ".Trash".  Files are
  28.  * initially moved to a <i>current</i> sub-directory of the trash directory.
  29.  * Within that sub-directory their original path is preserved.  Periodically
  30.  * one may checkpoint the current trash and remove older checkpoints.  (This
  31.  * design permits trash management without enumeration of the full trash
  32.  * content, without date support in the filesystem, and without clock
  33.  * synchronization.)
  34.  */
  35. public class Trash extends Configured {
  36.   private static final Log LOG =
  37.     LogFactory.getLog(Trash.class);
  38.   private static final Path CURRENT = new Path("Current");
  39.   private static final Path TRASH = new Path(".Trash/");
  40.   private static final Path HOMES = new Path("/user/");
  41.   private static final FsPermission PERMISSION =
  42.     new FsPermission(FsAction.ALL, FsAction.NONE, FsAction.NONE);
  43.   private static final DateFormat CHECKPOINT = new SimpleDateFormat("yyMMddHHmm");
  44.   private static final int MSECS_PER_MINUTE = 60*1000;
  45.   private final FileSystem fs;
  46.   private final Path trash;
  47.   private final Path current;
  48.   private final long interval;
  49.   /** Construct a trash can accessor.
  50.    * @param conf a Configuration
  51.    */
  52.   public Trash(Configuration conf) throws IOException {
  53.     this(FileSystem.get(conf), conf);
  54.   }
  55.   /**
  56.    * Construct a trash can accessor for the FileSystem provided.
  57.    */
  58.   public Trash(FileSystem fs, Configuration conf) throws IOException {
  59.     super(conf);
  60.     this.fs = fs;
  61.     this.trash = new Path(fs.getHomeDirectory(), TRASH);
  62.     this.current = new Path(trash, CURRENT);
  63.     this.interval = conf.getLong("fs.trash.interval", 60) * MSECS_PER_MINUTE;
  64.   }
  65.   private Trash(Path home, Configuration conf) throws IOException {
  66.     super(conf);
  67.     this.fs = home.getFileSystem(conf);
  68.     this.trash = new Path(home, TRASH);
  69.     this.current = new Path(trash, CURRENT);
  70.     this.interval = conf.getLong("fs.trash.interval", 60) * MSECS_PER_MINUTE;
  71.   }
  72.   
  73.   private Path makeTrashRelativePath(Path basePath, Path rmFilePath) {
  74.     return new Path(basePath + rmFilePath.toUri().getPath());
  75.   }
  76.   /** Move a file or directory to the current trash directory.
  77.    * @return false if the item is already in the trash or trash is disabled
  78.    */ 
  79.   public boolean moveToTrash(Path path) throws IOException {
  80.     if (interval == 0)
  81.       return false;
  82.     if (!path.isAbsolute())                       // make path absolute
  83.       path = new Path(fs.getWorkingDirectory(), path);
  84.     if (!fs.exists(path))                         // check that path exists
  85.       throw new FileNotFoundException(path.toString());
  86.     String qpath = path.makeQualified(fs).toString();
  87.     if (qpath.startsWith(trash.toString())) {
  88.       return false;                               // already in trash
  89.     }
  90.     if (trash.getParent().toString().startsWith(qpath)) {
  91.       throw new IOException("Cannot move "" + path +
  92.                             "" to the trash, as it contains the trash");
  93.     }
  94.     Path trashPath = makeTrashRelativePath(current, path);
  95.     Path baseTrashPath = makeTrashRelativePath(current, path.getParent());
  96.     
  97.     IOException cause = null;
  98.     // try twice, in case checkpoint between the mkdirs() & rename()
  99.     for (int i = 0; i < 2; i++) {
  100.       try {
  101.         if (!fs.mkdirs(baseTrashPath, PERMISSION)) {      // create current
  102.           LOG.warn("Can't create trash directory: "+baseTrashPath);
  103.           return false;
  104.         }
  105.       } catch (IOException e) {
  106.         LOG.warn("Can't create trash directory: "+baseTrashPath);
  107.         return false;
  108.       }
  109.       try {
  110.         //
  111.         // if the target path in Trash already exists, then append with 
  112.         // a number. Start from 1.
  113.         //
  114.         String orig = trashPath.toString();
  115.         for (int j = 1; fs.exists(trashPath); j++) {
  116.           trashPath = new Path(orig + "." + j);
  117.         }
  118.         if (fs.rename(path, trashPath))           // move to current trash
  119.           return true;
  120.       } catch (IOException e) {
  121.         cause = e;
  122.       }
  123.     }
  124.     throw (IOException)
  125.       new IOException("Failed to move to trash: "+path).initCause(cause);
  126.   }
  127.   /** Create a trash checkpoint. */
  128.   public void checkpoint() throws IOException {
  129.     if (!fs.exists(current))                      // no trash, no checkpoint
  130.       return;
  131.     Path checkpoint;
  132.     synchronized (CHECKPOINT) {
  133.       checkpoint = new Path(trash, CHECKPOINT.format(new Date()));
  134.     }
  135.     if (fs.rename(current, checkpoint)) {
  136.       LOG.info("Created trash checkpoint: "+checkpoint.toUri().getPath());
  137.     } else {
  138.       throw new IOException("Failed to checkpoint trash: "+checkpoint);
  139.     }
  140.   }
  141.   /** Delete old checkpoints. */
  142.   public void expunge() throws IOException {
  143.     FileStatus[] dirs = fs.listStatus(trash);            // scan trash sub-directories
  144.     if( dirs == null){
  145.       return;
  146.     }
  147.     long now = System.currentTimeMillis();
  148.     for (int i = 0; i < dirs.length; i++) {
  149.       Path path = dirs[i].getPath();
  150.       String dir = path.toUri().getPath();
  151.       String name = path.getName();
  152.       if (name.equals(CURRENT.getName()))         // skip current
  153.         continue;
  154.       long time;
  155.       try {
  156.         synchronized (CHECKPOINT) {
  157.           time = CHECKPOINT.parse(name).getTime();
  158.         }
  159.       } catch (ParseException e) {
  160.         LOG.warn("Unexpected item in trash: "+dir+". Ignoring.");
  161.         continue;
  162.       }
  163.       if ((now - interval) > time) {
  164.         if (fs.delete(path, true)) {
  165.           LOG.info("Deleted trash checkpoint: "+dir);
  166.         } else {
  167.           LOG.warn("Couldn't delete checkpoint: "+dir+" Ignoring.");
  168.         }
  169.       }
  170.     }
  171.   }
  172.   //
  173.   // get the current working directory
  174.   //
  175.   Path getCurrentTrashDir() {
  176.     return current;
  177.   }
  178.   /** Return a {@link Runnable} that periodically empties the trash of all
  179.    * users, intended to be run by the superuser.  Only one checkpoint is kept
  180.    * at a time.
  181.    */
  182.   public Runnable getEmptier() throws IOException {
  183.     return new Emptier(getConf());
  184.   }
  185.   private static class Emptier implements Runnable {
  186.     private Configuration conf;
  187.     private FileSystem fs;
  188.     private long interval;
  189.     public Emptier(Configuration conf) throws IOException {
  190.       this.conf = conf;
  191.       this.interval = conf.getLong("fs.trash.interval", 60) * MSECS_PER_MINUTE;
  192.       this.fs = FileSystem.get(conf);
  193.     }
  194.     public void run() {
  195.       if (interval == 0)
  196.         return;                                   // trash disabled
  197.       long now = System.currentTimeMillis();
  198.       long end;
  199.       while (true) {
  200.         end = ceiling(now, interval);
  201.         try {                                     // sleep for interval
  202.           Thread.sleep(end - now);
  203.         } catch (InterruptedException e) {
  204.           return;                                 // exit on interrupt
  205.         }
  206.           
  207.         try {
  208.           now = System.currentTimeMillis();
  209.           if (now >= end) {
  210.             FileStatus[] homes = null;
  211.             try {
  212.               homes = fs.listStatus(HOMES);         // list all home dirs
  213.             } catch (IOException e) {
  214.               LOG.warn("Trash can't list homes: "+e+" Sleeping.");
  215.               continue;
  216.             }
  217.             if (homes == null)
  218.               continue;
  219.             for (FileStatus home : homes) {         // dump each trash
  220.               if (!home.isDir())
  221.                 continue;
  222.               try {
  223.                 Trash trash = new Trash(home.getPath(), conf);
  224.                 trash.expunge();
  225.                 trash.checkpoint();
  226.               } catch (IOException e) {
  227.                 LOG.warn("Trash caught: "+e+". Skipping "+home.getPath()+".");
  228.               } 
  229.             }
  230.           }
  231.         } catch (Exception e) {
  232.           LOG.warn("RuntimeException during Trash.Emptier.run() " + 
  233.                    StringUtils.stringifyException(e));
  234.         }
  235.       }
  236.     }
  237.     private long ceiling(long time, long interval) {
  238.       return floor(time, interval) + interval;
  239.     }
  240.     private long floor(long time, long interval) {
  241.       return (time / interval) * interval;
  242.     }
  243.   }
  244.   /** Run an emptier.*/
  245.   public static void main(String[] args) throws Exception {
  246.     new Trash(new Configuration()).getEmptier().run();
  247.   }
  248. }