/**
* 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();
}
};