DFSFile.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.eclipse.dfs;
  19. import java.io.BufferedInputStream;
  20. import java.io.BufferedOutputStream;
  21. import java.io.DataInputStream;
  22. import java.io.DataOutputStream;
  23. import java.io.File;
  24. import java.io.FileInputStream;
  25. import java.io.FileOutputStream;
  26. import java.io.IOException;
  27. import java.io.InputStream;
  28. import java.lang.reflect.InvocationTargetException;
  29. import org.apache.hadoop.eclipse.Activator;
  30. import org.apache.hadoop.eclipse.ErrorMessageDialog;
  31. import org.apache.hadoop.fs.FileStatus;
  32. import org.apache.hadoop.fs.Path;
  33. import org.eclipse.core.resources.IStorage;
  34. import org.eclipse.core.runtime.CoreException;
  35. import org.eclipse.core.runtime.IPath;
  36. import org.eclipse.core.runtime.IProgressMonitor;
  37. import org.eclipse.core.runtime.PlatformObject;
  38. import org.eclipse.core.runtime.Status;
  39. import org.eclipse.jface.dialogs.MessageDialog;
  40. import org.eclipse.jface.operation.IRunnableWithProgress;
  41. import org.eclipse.ui.PlatformUI;
  42. /**
  43.  * File handling methods for the DFS
  44.  */
  45. public class DFSFile extends DFSPath implements DFSContent {
  46.   protected long length;
  47.   protected short replication;
  48.   /**
  49.    * Constructor to upload a file on the distributed file system
  50.    * 
  51.    * @param parent
  52.    * @param path
  53.    * @param file
  54.    * @param monitor
  55.    */
  56.   public DFSFile(DFSPath parent, Path path, File file,
  57.       IProgressMonitor monitor) {
  58.     super(parent, path);
  59.     this.upload(monitor, file);
  60.   }
  61.   public DFSFile(DFSPath parent, Path path) {
  62.     super(parent, path);
  63.     try {
  64.       FileStatus fs = getDFS().getFileStatus(path);
  65.       this.length = fs.getLen();
  66.       this.replication = fs.getReplication();
  67.     } catch (IOException e) {
  68.       e.printStackTrace();
  69.     }
  70.   }
  71.   /**
  72.    * Download and view contents of a file
  73.    * 
  74.    * @return a InputStream for the file
  75.    */
  76.   public InputStream open() throws IOException {
  77.     return getDFS().open(this.path);
  78.   }
  79.   /**
  80.    * Download this file to the local file system. This creates a download
  81.    * status monitor.
  82.    * 
  83.    * @param file
  84.    * @throws JSchException
  85.    * @throws IOException
  86.    * @throws InvocationTargetException
  87.    * @throws InterruptedException
  88.    * 
  89.    * @deprecated
  90.    */
  91.   public void downloadToLocalFile(final File file)
  92.       throws InvocationTargetException, InterruptedException {
  93.     PlatformUI.getWorkbench().getProgressService().busyCursorWhile(
  94.         new IRunnableWithProgress() {
  95.           public void run(IProgressMonitor monitor)
  96.               throws InvocationTargetException {
  97.             DFSFile.this.downloadToLocalFile(monitor, file);
  98.           }
  99.         });
  100.   }
  101.   /* @inheritDoc */
  102.   @Override
  103.   public void downloadToLocalDirectory(IProgressMonitor monitor, File dir) {
  104.     File dfsPath = new File(this.getPath().toString());
  105.     File destination = new File(dir, dfsPath.getName());
  106.     if (destination.exists()) {
  107.       boolean answer =
  108.           MessageDialog.openQuestion(null, "Overwrite existing local file?",
  109.               "The file you are attempting to download from the DFS "
  110.                   + this.getPath()
  111.                   + ", already exists in your local directory as "
  112.                   + destination + ".n" + "Overwrite the existing file?");
  113.       if (!answer)
  114.         return;
  115.     }
  116.     try {
  117.       this.downloadToLocalFile(monitor, destination);
  118.     } catch (Exception e) {
  119.       e.printStackTrace();
  120.       MessageDialog.openWarning(null, "Download to local file system",
  121.           "Downloading of file "" + this.path + "" to local directory ""
  122.               + dir + "" has failed.n" + e);
  123.     }
  124.   }
  125.   /**
  126.    * Provides a detailed string for this file
  127.    * 
  128.    * @return the string formatted as
  129.    *         <tt>&lt;filename&gt; (&lt;size&gt;, r&lt;replication&gt;)</tt>
  130.    */
  131.   public String toDetailedString() {
  132.     final String[] units = { "b", "Kb", "Mb", "Gb", "Tb" };
  133.     int unit = 0;
  134.     double l = this.length;
  135.     while ((l >= 1024.0) && (unit < units.length)) {
  136.       unit += 1;
  137.       l /= 1024.0;
  138.     }
  139.     return String.format("%s (%.1f %s, r%d)", super.toString(), l,
  140.         units[unit], this.replication);
  141.   }
  142.   /* @inheritDoc */
  143.   @Override
  144.   public String toString() {
  145.     return this.path.toString();
  146.   }
  147.   /*
  148.    * 
  149.    */
  150.   /**
  151.    * Download the DfsFile to a local file. Use the given monitor to report
  152.    * status of operation.
  153.    * 
  154.    * @param monitor the status monitor
  155.    * @param file the local file where to put the downloaded file
  156.    * @throws InvocationTargetException
  157.    */
  158.   public void downloadToLocalFile(IProgressMonitor monitor, File file)
  159.       throws InvocationTargetException {
  160.     final int taskSize = 1024;
  161.     monitor.setTaskName("Download file " + this.path);
  162.     BufferedOutputStream ostream = null;
  163.     DataInputStream istream = null;
  164.     try {
  165.       istream = getDFS().open(this.path);
  166.       ostream = new BufferedOutputStream(new FileOutputStream(file));
  167.       int bytes;
  168.       byte[] buffer = new byte[taskSize];
  169.       while ((bytes = istream.read(buffer)) >= 0) {
  170.         if (monitor.isCanceled())
  171.           return;
  172.         ostream.write(buffer, 0, bytes);
  173.         monitor.worked(1);
  174.       }
  175.     } catch (Exception e) {
  176.       throw new InvocationTargetException(e);
  177.     } finally {
  178.       // Clean all opened resources
  179.       if (istream != null) {
  180.         try {
  181.           istream.close();
  182.         } catch (IOException e) {
  183.           e.printStackTrace();
  184.           // nothing we can do here
  185.         }
  186.       }
  187.       try {
  188.         ostream.close();
  189.       } catch (IOException e) {
  190.         e.printStackTrace();
  191.         // nothing we can do here
  192.       }
  193.     }
  194.   }
  195.   /**
  196.    * Upload a local file to this file on the distributed file system
  197.    * 
  198.    * @param monitor
  199.    * @param file
  200.    */
  201.   public void upload(IProgressMonitor monitor, File file) {
  202.     final int taskSize = 1024;
  203.     monitor.setTaskName("Upload file " + this.path);
  204.     BufferedInputStream istream = null;
  205.     DataOutputStream ostream = null;
  206.     try {
  207.       istream = new BufferedInputStream(new FileInputStream(file));
  208.       ostream = getDFS().create(this.path);
  209.       int bytes;
  210.       byte[] buffer = new byte[taskSize];
  211.       while ((bytes = istream.read(buffer)) >= 0) {
  212.         if (monitor.isCanceled())
  213.           return;
  214.         ostream.write(buffer, 0, bytes);
  215.         monitor.worked(1);
  216.       }
  217.     } catch (Exception e) {
  218.       ErrorMessageDialog.display(String.format(
  219.           "Unable to uploade file %s to %s", file, this.path), e
  220.           .getLocalizedMessage());
  221.     } finally {
  222.       try {
  223.         if (istream != null)
  224.           istream.close();
  225.       } catch (IOException e) {
  226.         e.printStackTrace();
  227.         // nothing we can do here
  228.       }
  229.       try {
  230.         if (ostream != null)
  231.           ostream.close();
  232.       } catch (IOException e) {
  233.         e.printStackTrace();
  234.         // nothing we can do here
  235.       }
  236.     }
  237.   }
  238.   /* @inheritDoc */
  239.   @Override
  240.   public void refresh() {
  241.     getParent().refresh();
  242.   }
  243.   /* @inheritDoc */
  244.   @Override
  245.   public int computeDownloadWork() {
  246.     return 1 + (int) (this.length / 1024);
  247.   }
  248.   /**
  249.    * Creates an adapter for the file to open it in the Editor
  250.    * 
  251.    * @return the IStorage
  252.    */
  253.   public IStorage getIStorage() {
  254.     return new IStorageAdapter();
  255.   }
  256.   /**
  257.    * IStorage adapter to open the file in the Editor
  258.    */
  259.   private class IStorageAdapter extends PlatformObject implements IStorage {
  260.     /* @inheritDoc */
  261.     public InputStream getContents() throws CoreException {
  262.       try {
  263.         return DFSFile.this.open();
  264.       } catch (IOException ioe) {
  265.         throw new CoreException(new Status(Status.ERROR,
  266.                 Activator.PLUGIN_ID, 0, "Unable to open file ""
  267.                 + DFSFile.this.path + """, ioe));
  268.       }
  269.     }
  270.     /* @inheritDoc */
  271.     public IPath getFullPath() {
  272.       return new org.eclipse.core.runtime.Path(DFSFile.this.path.toString());
  273.     }
  274.     /* @inheritDoc */
  275.     public String getName() {
  276.       return DFSFile.this.path.getName();
  277.     }
  278.     /* @inheritDoc */
  279.     public boolean isReadOnly() {
  280.       return true;
  281.     }
  282.   }
  283.   /*
  284.    * Implementation of DFSContent
  285.    */
  286.   /* @inheritDoc */
  287.   public DFSContent[] getChildren() {
  288.     return null;
  289.   }
  290.   /* @inheritDoc */
  291.   public boolean hasChildren() {
  292.     return false;
  293.   }
  294. }