| /** |
| * Licensed to the Apache Software Foundation (ASF) under one |
| * or more contributor license agreements. See the NOTICE file |
| * distributed with this work for additional information |
| * regarding copyright ownership. The ASF licenses this file |
| * to you under the Apache License, Version 2.0 (the |
| * "License"); you may not use this file except in compliance |
| * with the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| package org.apache.hadoop.eclipse.actions; |
| |
| import java.io.File; |
| import java.io.IOException; |
| import java.lang.reflect.InvocationTargetException; |
| import java.util.ArrayList; |
| import java.util.HashSet; |
| import java.util.List; |
| import java.util.Set; |
| |
| import org.apache.hadoop.eclipse.ImageLibrary; |
| import org.apache.hadoop.eclipse.dfs.DFSActions; |
| import org.apache.hadoop.eclipse.dfs.DFSFile; |
| import org.apache.hadoop.eclipse.dfs.DFSFolder; |
| import org.apache.hadoop.eclipse.dfs.DFSLocation; |
| import org.apache.hadoop.eclipse.dfs.DFSLocationsRoot; |
| import org.apache.hadoop.eclipse.dfs.DFSPath; |
| import org.eclipse.core.resources.IStorage; |
| import org.eclipse.core.runtime.CoreException; |
| import org.eclipse.core.runtime.IProgressMonitor; |
| import org.eclipse.core.runtime.PlatformObject; |
| import org.eclipse.jface.action.IAction; |
| import org.eclipse.jface.dialogs.InputDialog; |
| import org.eclipse.jface.dialogs.MessageDialog; |
| import org.eclipse.jface.operation.IRunnableWithProgress; |
| import org.eclipse.jface.resource.ImageDescriptor; |
| import org.eclipse.jface.viewers.ISelection; |
| import org.eclipse.jface.viewers.IStructuredSelection; |
| import org.eclipse.swt.SWT; |
| import org.eclipse.swt.widgets.DirectoryDialog; |
| import org.eclipse.swt.widgets.Display; |
| import org.eclipse.swt.widgets.FileDialog; |
| import org.eclipse.ui.IObjectActionDelegate; |
| import org.eclipse.ui.IPersistableElement; |
| import org.eclipse.ui.IStorageEditorInput; |
| import org.eclipse.ui.IWorkbenchPart; |
| import org.eclipse.ui.PartInitException; |
| import org.eclipse.ui.PlatformUI; |
| |
| /** |
| * Actual implementation of DFS actions |
| */ |
| public class DFSActionImpl implements IObjectActionDelegate { |
| |
| private ISelection selection; |
| |
| private IWorkbenchPart targetPart; |
| |
| /* @inheritDoc */ |
| public void setActivePart(IAction action, IWorkbenchPart targetPart) { |
| this.targetPart = targetPart; |
| } |
| |
| /* @inheritDoc */ |
| public void run(IAction action) { |
| |
| // Ignore non structured selections |
| if (!(this.selection instanceof IStructuredSelection)) |
| return; |
| |
| // operate on the DFS asynchronously to prevent blocking the main UI |
| final IStructuredSelection ss = (IStructuredSelection) selection; |
| final String actionId = action.getActionDefinitionId(); |
| Display.getDefault().asyncExec(new Runnable() { |
| public void run() { |
| try { |
| switch (DFSActions.getById(actionId)) { |
| case DELETE: { |
| delete(ss); |
| break; |
| } |
| case OPEN: { |
| open(ss); |
| break; |
| } |
| case MKDIR: { |
| mkdir(ss); |
| break; |
| } |
| case UPLOAD_FILES: { |
| uploadFilesToDFS(ss); |
| break; |
| } |
| case UPLOAD_DIR: { |
| uploadDirectoryToDFS(ss); |
| break; |
| } |
| case REFRESH: { |
| refresh(ss); |
| break; |
| } |
| case DOWNLOAD: { |
| downloadFromDFS(ss); |
| break; |
| } |
| case RECONNECT: { |
| reconnect(ss); |
| break; |
| } |
| case DISCONNECT: { |
| disconnect(ss); |
| break; |
| } |
| default: { |
| System.err.printf("Unhandled DFS Action: " + actionId); |
| break; |
| } |
| } |
| |
| } catch (Exception e) { |
| e.printStackTrace(); |
| MessageDialog.openError(Display.getDefault().getActiveShell(), |
| "DFS Action error", |
| "An error occurred while performing DFS operation: " |
| + e.getMessage()); |
| } |
| } |
| }); |
| } |
| |
| /** |
| * Create a new sub-folder into an existing directory |
| * |
| * @param selection |
| */ |
| private void mkdir(IStructuredSelection selection) { |
| List<DFSFolder> folders = filterSelection(DFSFolder.class, selection); |
| if (folders.size() >= 1) { |
| DFSFolder folder = folders.get(0); |
| InputDialog dialog = |
| new InputDialog(Display.getCurrent().getActiveShell(), |
| "Create subfolder", "Enter the name of the subfolder", "", |
| null); |
| if (dialog.open() == InputDialog.OK) |
| folder.mkdir(dialog.getValue()); |
| } |
| } |
| |
| /** |
| * Implement the import action (upload files from the current machine to |
| * HDFS) |
| * |
| * @param object |
| * @throws SftpException |
| * @throws JSchException |
| * @throws InvocationTargetException |
| * @throws InterruptedException |
| */ |
| private void uploadFilesToDFS(IStructuredSelection selection) |
| throws InvocationTargetException, InterruptedException { |
| |
| // Ask the user which files to upload |
| FileDialog dialog = |
| new FileDialog(Display.getCurrent().getActiveShell(), SWT.OPEN |
| | SWT.MULTI); |
| dialog.setText("Select the local files to upload"); |
| dialog.open(); |
| |
| List<File> files = new ArrayList<File>(); |
| for (String fname : dialog.getFileNames()) |
| files.add(new File(dialog.getFilterPath() + File.separator + fname)); |
| |
| // TODO enable upload command only when selection is exactly one folder |
| List<DFSFolder> folders = filterSelection(DFSFolder.class, selection); |
| if (folders.size() >= 1) |
| uploadToDFS(folders.get(0), files); |
| } |
| |
| /** |
| * Implement the import action (upload directory from the current machine |
| * to HDFS) |
| * |
| * @param object |
| * @throws SftpException |
| * @throws JSchException |
| * @throws InvocationTargetException |
| * @throws InterruptedException |
| */ |
| private void uploadDirectoryToDFS(IStructuredSelection selection) |
| throws InvocationTargetException, InterruptedException { |
| |
| // Ask the user which local directory to upload |
| DirectoryDialog dialog = |
| new DirectoryDialog(Display.getCurrent().getActiveShell(), SWT.OPEN |
| | SWT.MULTI); |
| dialog.setText("Select the local file or directory to upload"); |
| |
| String dirName = dialog.open(); |
| final File dir = new File(dirName); |
| List<File> files = new ArrayList<File>(); |
| files.add(dir); |
| |
| // TODO enable upload command only when selection is exactly one folder |
| final List<DFSFolder> folders = |
| filterSelection(DFSFolder.class, selection); |
| if (folders.size() >= 1) |
| uploadToDFS(folders.get(0), files); |
| |
| } |
| |
| private void uploadToDFS(final DFSFolder folder, final List<File> files) |
| throws InvocationTargetException, InterruptedException { |
| |
| PlatformUI.getWorkbench().getProgressService().busyCursorWhile( |
| new IRunnableWithProgress() { |
| public void run(IProgressMonitor monitor) |
| throws InvocationTargetException { |
| |
| int work = 0; |
| for (File file : files) |
| work += computeUploadWork(file); |
| |
| monitor.beginTask("Uploading files to distributed file system", |
| work); |
| |
| for (File file : files) { |
| try { |
| folder.upload(monitor, file); |
| |
| } catch (IOException ioe) { |
| ioe.printStackTrace(); |
| MessageDialog.openError(null, |
| "Upload files to distributed file system", |
| "Upload failed.\n" + ioe); |
| } |
| } |
| |
| monitor.done(); |
| |
| // Update the UI |
| folder.doRefresh(); |
| } |
| }); |
| } |
| |
| private void reconnect(IStructuredSelection selection) { |
| for (DFSLocation location : filterSelection(DFSLocation.class, selection)) |
| location.reconnect(); |
| } |
| |
| private void disconnect(IStructuredSelection selection) { |
| if (selection.size() != 1) |
| return; |
| |
| Object first = selection.getFirstElement(); |
| if (!(first instanceof DFSLocationsRoot)) |
| return; |
| |
| DFSLocationsRoot root = (DFSLocationsRoot) first; |
| root.disconnect(); |
| root.refresh(); |
| } |
| |
| /** |
| * Implements the Download action from HDFS to the current machine |
| * |
| * @param object |
| * @throws SftpException |
| * @throws JSchException |
| * @throws InterruptedException |
| * @throws InvocationTargetException |
| */ |
| private void downloadFromDFS(IStructuredSelection selection) |
| throws InvocationTargetException, InterruptedException { |
| |
| // Ask the user where to put the downloaded files |
| DirectoryDialog dialog = |
| new DirectoryDialog(Display.getCurrent().getActiveShell()); |
| dialog.setText("Copy to local directory"); |
| dialog.setMessage("Copy the selected files and directories from the " |
| + "distributed filesystem to a local directory"); |
| String directory = dialog.open(); |
| |
| if (directory == null) |
| return; |
| |
| final File dir = new File(directory); |
| if (!dir.exists()) |
| dir.mkdirs(); |
| |
| if (!dir.isDirectory()) { |
| MessageDialog.openError(null, "Download to local file system", |
| "Invalid directory location: \"" + dir + "\""); |
| return; |
| } |
| |
| final List<DFSPath> paths = filterSelection(DFSPath.class, selection); |
| |
| PlatformUI.getWorkbench().getProgressService().busyCursorWhile( |
| new IRunnableWithProgress() { |
| public void run(IProgressMonitor monitor) |
| throws InvocationTargetException { |
| |
| int work = 0; |
| for (DFSPath path : paths) |
| work += path.computeDownloadWork(); |
| |
| monitor |
| .beginTask("Downloading files to local file system", work); |
| |
| for (DFSPath path : paths) { |
| if (monitor.isCanceled()) |
| return; |
| try { |
| path.downloadToLocalDirectory(monitor, dir); |
| } catch (Exception e) { |
| // nothing we want to do here |
| e.printStackTrace(); |
| } |
| } |
| |
| monitor.done(); |
| } |
| }); |
| } |
| |
| /** |
| * Open the selected DfsPath in the editor window |
| * |
| * @param selection |
| * @throws JSchException |
| * @throws IOException |
| * @throws PartInitException |
| * @throws InvocationTargetException |
| * @throws InterruptedException |
| */ |
| private void open(IStructuredSelection selection) throws IOException, |
| PartInitException, InvocationTargetException, InterruptedException { |
| |
| for (DFSFile file : filterSelection(DFSFile.class, selection)) { |
| |
| IStorageEditorInput editorInput = new DFSFileEditorInput(file); |
| targetPart.getSite().getWorkbenchWindow().getActivePage().openEditor( |
| editorInput, "org.eclipse.ui.DefaultTextEditor"); |
| } |
| } |
| |
| /** |
| * @param selection |
| * @throws JSchException |
| */ |
| private void refresh(IStructuredSelection selection) { |
| for (DFSPath path : filterSelection(DFSPath.class, selection)) |
| path.refresh(); |
| |
| } |
| |
| private void delete(IStructuredSelection selection) { |
| List<DFSPath> list = filterSelection(DFSPath.class, selection); |
| if (list.isEmpty()) |
| return; |
| |
| StringBuffer msg = new StringBuffer(); |
| msg.append("Are you sure you want to delete " |
| + "the following files from the distributed file system?\n"); |
| for (DFSPath path : list) |
| msg.append(path.getPath()).append("\n"); |
| |
| if (MessageDialog.openConfirm(null, "Confirm Delete from DFS", msg |
| .toString())) { |
| |
| Set<DFSPath> toRefresh = new HashSet<DFSPath>(); |
| for (DFSPath path : list) { |
| path.delete(); |
| toRefresh.add(path.getParent()); |
| } |
| |
| for (DFSPath path : toRefresh) { |
| path.refresh(); |
| } |
| } |
| } |
| |
| /* @inheritDoc */ |
| public void selectionChanged(IAction action, ISelection selection) { |
| this.selection = selection; |
| } |
| |
| /** |
| * Extract the list of <T> from the structured selection |
| * |
| * @param clazz the class T |
| * @param selection the structured selection |
| * @return the list of <T> it contains |
| */ |
| private static <T> List<T> filterSelection(Class<T> clazz, |
| IStructuredSelection selection) { |
| List<T> list = new ArrayList<T>(); |
| for (Object obj : selection.toList()) { |
| if (clazz.isAssignableFrom(obj.getClass())) { |
| list.add((T) obj); |
| } |
| } |
| return list; |
| } |
| |
| private static int computeUploadWork(File file) { |
| if (file.isDirectory()) { |
| int contentWork = 1; |
| for (File child : file.listFiles()) |
| contentWork += computeUploadWork(child); |
| return contentWork; |
| |
| } else if (file.isFile()) { |
| return 1 + (int) (file.length() / 1024); |
| |
| } else { |
| return 0; |
| } |
| } |
| |
| } |
| |
| /** |
| * Adapter to allow the viewing of a DfsFile in the Editor window |
| */ |
| class DFSFileEditorInput extends PlatformObject implements |
| IStorageEditorInput { |
| |
| private DFSFile file; |
| |
| /** |
| * Constructor |
| * |
| * @param file |
| */ |
| DFSFileEditorInput(DFSFile file) { |
| this.file = file; |
| } |
| |
| /* @inheritDoc */ |
| public String getToolTipText() { |
| return file.toDetailedString(); |
| } |
| |
| /* @inheritDoc */ |
| public IPersistableElement getPersistable() { |
| return null; |
| } |
| |
| /* @inheritDoc */ |
| public String getName() { |
| return file.toString(); |
| } |
| |
| /* @inheritDoc */ |
| public ImageDescriptor getImageDescriptor() { |
| return ImageLibrary.get("dfs.file.editor"); |
| } |
| |
| /* @inheritDoc */ |
| public boolean exists() { |
| return true; |
| } |
| |
| /* @inheritDoc */ |
| public IStorage getStorage() throws CoreException { |
| return file.getIStorage(); |
| } |
| }; |
