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

网格计算

开发平台:

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.actions;
  19. import java.io.File;
  20. import java.io.IOException;
  21. import java.lang.reflect.InvocationTargetException;
  22. import java.util.ArrayList;
  23. import java.util.HashSet;
  24. import java.util.List;
  25. import java.util.Set;
  26. import org.apache.hadoop.eclipse.ImageLibrary;
  27. import org.apache.hadoop.eclipse.dfs.DFSActions;
  28. import org.apache.hadoop.eclipse.dfs.DFSFile;
  29. import org.apache.hadoop.eclipse.dfs.DFSFolder;
  30. import org.apache.hadoop.eclipse.dfs.DFSLocation;
  31. import org.apache.hadoop.eclipse.dfs.DFSLocationsRoot;
  32. import org.apache.hadoop.eclipse.dfs.DFSPath;
  33. import org.eclipse.core.resources.IStorage;
  34. import org.eclipse.core.runtime.CoreException;
  35. import org.eclipse.core.runtime.IProgressMonitor;
  36. import org.eclipse.core.runtime.PlatformObject;
  37. import org.eclipse.jface.action.IAction;
  38. import org.eclipse.jface.dialogs.InputDialog;
  39. import org.eclipse.jface.dialogs.MessageDialog;
  40. import org.eclipse.jface.operation.IRunnableWithProgress;
  41. import org.eclipse.jface.resource.ImageDescriptor;
  42. import org.eclipse.jface.viewers.ISelection;
  43. import org.eclipse.jface.viewers.IStructuredSelection;
  44. import org.eclipse.swt.SWT;
  45. import org.eclipse.swt.widgets.DirectoryDialog;
  46. import org.eclipse.swt.widgets.Display;
  47. import org.eclipse.swt.widgets.FileDialog;
  48. import org.eclipse.ui.IObjectActionDelegate;
  49. import org.eclipse.ui.IPersistableElement;
  50. import org.eclipse.ui.IStorageEditorInput;
  51. import org.eclipse.ui.IWorkbenchPart;
  52. import org.eclipse.ui.PartInitException;
  53. import org.eclipse.ui.PlatformUI;
  54. /**
  55.  * Actual implementation of DFS actions
  56.  */
  57. public class DFSActionImpl implements IObjectActionDelegate {
  58.   private ISelection selection;
  59.   private IWorkbenchPart targetPart;
  60.   /* @inheritDoc */
  61.   public void setActivePart(IAction action, IWorkbenchPart targetPart) {
  62.     this.targetPart = targetPart;
  63.   }
  64.   /* @inheritDoc */
  65.   public void run(IAction action) {
  66.     // Ignore non structured selections
  67.     if (!(this.selection instanceof IStructuredSelection))
  68.       return;
  69.     // operate on the DFS asynchronously to prevent blocking the main UI
  70.     final IStructuredSelection ss = (IStructuredSelection) selection;
  71.     final String actionId = action.getActionDefinitionId();
  72.     Display.getDefault().asyncExec(new Runnable() {
  73.       public void run() {
  74.         try {
  75.           switch (DFSActions.getById(actionId)) {
  76.             case DELETE: {
  77.               delete(ss);
  78.               break;
  79.             }
  80.             case OPEN: {
  81.               open(ss);
  82.               break;
  83.             }
  84.             case MKDIR: {
  85.               mkdir(ss);
  86.               break;
  87.             }
  88.             case UPLOAD_FILES: {
  89.               uploadFilesToDFS(ss);
  90.               break;
  91.             }
  92.             case UPLOAD_DIR: {
  93.               uploadDirectoryToDFS(ss);
  94.               break;
  95.             }
  96.             case REFRESH: {
  97.               refresh(ss);
  98.               break;
  99.             }
  100.             case DOWNLOAD: {
  101.               downloadFromDFS(ss);
  102.               break;
  103.             }
  104.             case RECONNECT: {
  105.               reconnect(ss);
  106.               break;
  107.             }
  108.             case DISCONNECT: {
  109.               disconnect(ss);
  110.               break;
  111.             }
  112.             default: {
  113.               System.err.printf("Unhandled DFS Action: " + actionId);
  114.               break;
  115.             }
  116.           }
  117.         } catch (Exception e) {
  118.           e.printStackTrace();
  119.           MessageDialog.openError(Display.getDefault().getActiveShell(),
  120.               "DFS Action error",
  121.               "An error occurred while performing DFS operation: "
  122.                   + e.getMessage());
  123.         }
  124.       }
  125.     });
  126.   }
  127.   /**
  128.    * Create a new sub-folder into an existing directory
  129.    * 
  130.    * @param selection
  131.    */
  132.   private void mkdir(IStructuredSelection selection) {
  133.     List<DFSFolder> folders = filterSelection(DFSFolder.class, selection);
  134.     if (folders.size() >= 1) {
  135.       DFSFolder folder = folders.get(0);
  136.       InputDialog dialog =
  137.           new InputDialog(Display.getCurrent().getActiveShell(),
  138.               "Create subfolder", "Enter the name of the subfolder", "",
  139.               null);
  140.       if (dialog.open() == InputDialog.OK)
  141.         folder.mkdir(dialog.getValue());
  142.     }
  143.   }
  144.   /**
  145.    * Implement the import action (upload files from the current machine to
  146.    * HDFS)
  147.    * 
  148.    * @param object
  149.    * @throws SftpException
  150.    * @throws JSchException
  151.    * @throws InvocationTargetException
  152.    * @throws InterruptedException
  153.    */
  154.   private void uploadFilesToDFS(IStructuredSelection selection)
  155.       throws InvocationTargetException, InterruptedException {
  156.     // Ask the user which files to upload
  157.     FileDialog dialog =
  158.         new FileDialog(Display.getCurrent().getActiveShell(), SWT.OPEN
  159.             | SWT.MULTI);
  160.     dialog.setText("Select the local files to upload");
  161.     dialog.open();
  162.     List<File> files = new ArrayList<File>();
  163.     for (String fname : dialog.getFileNames())
  164.       files.add(new File(dialog.getFilterPath() + File.separator + fname));
  165.     // TODO enable upload command only when selection is exactly one folder
  166.     List<DFSFolder> folders = filterSelection(DFSFolder.class, selection);
  167.     if (folders.size() >= 1)
  168.       uploadToDFS(folders.get(0), files);
  169.   }
  170.   /**
  171.    * Implement the import action (upload directory from the current machine
  172.    * to HDFS)
  173.    * 
  174.    * @param object
  175.    * @throws SftpException
  176.    * @throws JSchException
  177.    * @throws InvocationTargetException
  178.    * @throws InterruptedException
  179.    */
  180.   private void uploadDirectoryToDFS(IStructuredSelection selection)
  181.       throws InvocationTargetException, InterruptedException {
  182.     // Ask the user which local directory to upload
  183.     DirectoryDialog dialog =
  184.         new DirectoryDialog(Display.getCurrent().getActiveShell(), SWT.OPEN
  185.             | SWT.MULTI);
  186.     dialog.setText("Select the local file or directory to upload");
  187.     String dirName = dialog.open();
  188.     final File dir = new File(dirName);
  189.     List<File> files = new ArrayList<File>();
  190.     files.add(dir);
  191.     // TODO enable upload command only when selection is exactly one folder
  192.     final List<DFSFolder> folders =
  193.         filterSelection(DFSFolder.class, selection);
  194.     if (folders.size() >= 1)
  195.       uploadToDFS(folders.get(0), files);
  196.   }
  197.   private void uploadToDFS(final DFSFolder folder, final List<File> files)
  198.       throws InvocationTargetException, InterruptedException {
  199.     PlatformUI.getWorkbench().getProgressService().busyCursorWhile(
  200.         new IRunnableWithProgress() {
  201.           public void run(IProgressMonitor monitor)
  202.               throws InvocationTargetException {
  203.             int work = 0;
  204.             for (File file : files)
  205.               work += computeUploadWork(file);
  206.             monitor.beginTask("Uploading files to distributed file system",
  207.                 work);
  208.             for (File file : files) {
  209.               try {
  210.                 folder.upload(monitor, file);
  211.               } catch (IOException ioe) {
  212.                 ioe.printStackTrace();
  213.                 MessageDialog.openError(null,
  214.                     "Upload files to distributed file system",
  215.                     "Upload failed.n" + ioe);
  216.               }
  217.             }
  218.             monitor.done();
  219.             // Update the UI
  220.             folder.doRefresh();
  221.           }
  222.         });
  223.   }
  224.   private void reconnect(IStructuredSelection selection) {
  225.     for (DFSLocation location : filterSelection(DFSLocation.class, selection))
  226.       location.reconnect();
  227.   }
  228.   private void disconnect(IStructuredSelection selection) {
  229.     if (selection.size() != 1)
  230.       return;
  231.     Object first = selection.getFirstElement();
  232.     if (!(first instanceof DFSLocationsRoot))
  233.       return;
  234.     DFSLocationsRoot root = (DFSLocationsRoot) first;
  235.     root.disconnect();
  236.     root.refresh();
  237.   }
  238.   /**
  239.    * Implements the Download action from HDFS to the current machine
  240.    * 
  241.    * @param object
  242.    * @throws SftpException
  243.    * @throws JSchException
  244.    * @throws InterruptedException
  245.    * @throws InvocationTargetException
  246.    */
  247.   private void downloadFromDFS(IStructuredSelection selection)
  248.       throws InvocationTargetException, InterruptedException {
  249.     // Ask the user where to put the downloaded files
  250.     DirectoryDialog dialog =
  251.         new DirectoryDialog(Display.getCurrent().getActiveShell());
  252.     dialog.setText("Copy to local directory");
  253.     dialog.setMessage("Copy the selected files and directories from the "
  254.         + "distributed filesystem to a local directory");
  255.     String directory = dialog.open();
  256.     if (directory == null)
  257.       return;
  258.     final File dir = new File(directory);
  259.     if (!dir.exists())
  260.       dir.mkdirs();
  261.     if (!dir.isDirectory()) {
  262.       MessageDialog.openError(null, "Download to local file system",
  263.           "Invalid directory location: "" + dir + """);
  264.       return;
  265.     }
  266.     final List<DFSPath> paths = filterSelection(DFSPath.class, selection);
  267.     PlatformUI.getWorkbench().getProgressService().busyCursorWhile(
  268.         new IRunnableWithProgress() {
  269.           public void run(IProgressMonitor monitor)
  270.               throws InvocationTargetException {
  271.             int work = 0;
  272.             for (DFSPath path : paths)
  273.               work += path.computeDownloadWork();
  274.             monitor
  275.                 .beginTask("Downloading files to local file system", work);
  276.             for (DFSPath path : paths) {
  277.               if (monitor.isCanceled())
  278.                 return;
  279.               try {
  280.                 path.downloadToLocalDirectory(monitor, dir);
  281.               } catch (Exception e) {
  282.                 // nothing we want to do here
  283.                 e.printStackTrace();
  284.               }
  285.             }
  286.             monitor.done();
  287.           }
  288.         });
  289.   }
  290.   /**
  291.    * Open the selected DfsPath in the editor window
  292.    * 
  293.    * @param selection
  294.    * @throws JSchException
  295.    * @throws IOException
  296.    * @throws PartInitException
  297.    * @throws InvocationTargetException
  298.    * @throws InterruptedException
  299.    */
  300.   private void open(IStructuredSelection selection) throws IOException,
  301.       PartInitException, InvocationTargetException, InterruptedException {
  302.     for (DFSFile file : filterSelection(DFSFile.class, selection)) {
  303.       IStorageEditorInput editorInput = new DFSFileEditorInput(file);
  304.       targetPart.getSite().getWorkbenchWindow().getActivePage().openEditor(
  305.           editorInput, "org.eclipse.ui.DefaultTextEditor");
  306.     }
  307.   }
  308.   /**
  309.    * @param selection
  310.    * @throws JSchException
  311.    */
  312.   private void refresh(IStructuredSelection selection) {
  313.     for (DFSPath path : filterSelection(DFSPath.class, selection))
  314.       path.refresh();
  315.   }
  316.   private void delete(IStructuredSelection selection) {
  317.     List<DFSPath> list = filterSelection(DFSPath.class, selection);
  318.     if (list.isEmpty())
  319.       return;
  320.     StringBuffer msg = new StringBuffer();
  321.     msg.append("Are you sure you want to delete "
  322.         + "the following files from the distributed file system?n");
  323.     for (DFSPath path : list)
  324.       msg.append(path.getPath()).append("n");
  325.     if (MessageDialog.openConfirm(null, "Confirm Delete from DFS", msg
  326.         .toString())) {
  327.       Set<DFSPath> toRefresh = new HashSet<DFSPath>();
  328.       for (DFSPath path : list) {
  329.         path.delete();
  330.         toRefresh.add(path.getParent());
  331.       }
  332.       for (DFSPath path : toRefresh) {
  333.         path.refresh();
  334.       }
  335.     }
  336.   }
  337.   /* @inheritDoc */
  338.   public void selectionChanged(IAction action, ISelection selection) {
  339.     this.selection = selection;
  340.   }
  341.   /**
  342.    * Extract the list of <T> from the structured selection
  343.    * 
  344.    * @param clazz the class T
  345.    * @param selection the structured selection
  346.    * @return the list of <T> it contains
  347.    */
  348.   private static <T> List<T> filterSelection(Class<T> clazz,
  349.       IStructuredSelection selection) {
  350.     List<T> list = new ArrayList<T>();
  351.     for (Object obj : selection.toList()) {
  352.       if (clazz.isAssignableFrom(obj.getClass())) {
  353.         list.add((T) obj);
  354.       }
  355.     }
  356.     return list;
  357.   }
  358.   private static int computeUploadWork(File file) {
  359.     if (file.isDirectory()) {
  360.       int contentWork = 1;
  361.       for (File child : file.listFiles())
  362.         contentWork += computeUploadWork(child);
  363.       return contentWork;
  364.     } else if (file.isFile()) {
  365.       return 1 + (int) (file.length() / 1024);
  366.     } else {
  367.       return 0;
  368.     }
  369.   }
  370. }
  371. /**
  372.  * Adapter to allow the viewing of a DfsFile in the Editor window
  373.  */
  374. class DFSFileEditorInput extends PlatformObject implements
  375.     IStorageEditorInput {
  376.   private DFSFile file;
  377.   /**
  378.    * Constructor
  379.    * 
  380.    * @param file
  381.    */
  382.   DFSFileEditorInput(DFSFile file) {
  383.     this.file = file;
  384.   }
  385.   /* @inheritDoc */
  386.   public String getToolTipText() {
  387.     return file.toDetailedString();
  388.   }
  389.   /* @inheritDoc */
  390.   public IPersistableElement getPersistable() {
  391.     return null;
  392.   }
  393.   /* @inheritDoc */
  394.   public String getName() {
  395.     return file.toString();
  396.   }
  397.   /* @inheritDoc */
  398.   public ImageDescriptor getImageDescriptor() {
  399.     return ImageLibrary.get("dfs.file.editor");
  400.   }
  401.   /* @inheritDoc */
  402.   public boolean exists() {
  403.     return true;
  404.   }
  405.   /* @inheritDoc */
  406.   public IStorage getStorage() throws CoreException {
  407.     return file.getIStorage();
  408.   }
  409. };