/**
* 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.dfs;
import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.lang.reflect.InvocationTargetException;
import org.apache.hadoop.eclipse.Activator;
import org.apache.hadoop.eclipse.ErrorMessageDialog;
import org.apache.hadoop.fs.FileStatus;
import org.apache.hadoop.fs.Path;
import org.eclipse.core.resources.IStorage;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IPath;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.PlatformObject;
import org.eclipse.core.runtime.Status;
import org.eclipse.jface.dialogs.MessageDialog;
import org.eclipse.jface.operation.IRunnableWithProgress;
import org.eclipse.ui.PlatformUI;
/**
* File handling methods for the DFS
*/
public class DFSFile extends DFSPath implements DFSContent {
protected long length;
protected short replication;
/**
* Constructor to upload a file on the distributed file system
*
* @param parent
* @param path
* @param file
* @param monitor
*/
public DFSFile(DFSPath parent, Path path, File file,
IProgressMonitor monitor) {
super(parent, path);
this.upload(monitor, file);
}
public DFSFile(DFSPath parent, Path path) {
super(parent, path);
try {
FileStatus fs = getDFS().getFileStatus(path);
this.length = fs.getLen();
this.replication = fs.getReplication();
} catch (IOException e) {
e.printStackTrace();
}
}
/**
* Download and view contents of a file
*
* @return a InputStream for the file
*/
public InputStream open() throws IOException {
return getDFS().open(this.path);
}
/**
* Download this file to the local file system. This creates a download
* status monitor.
*
* @param file
* @throws JSchException
* @throws IOException
* @throws InvocationTargetException
* @throws InterruptedException
*
* @deprecated
*/
public void downloadToLocalFile(final File file)
throws InvocationTargetException, InterruptedException {
PlatformUI.getWorkbench().getProgressService().busyCursorWhile(
new IRunnableWithProgress() {
public void run(IProgressMonitor monitor)
throws InvocationTargetException {
DFSFile.this.downloadToLocalFile(monitor, file);
}
});
}
/* @inheritDoc */
@Override
public void downloadToLocalDirectory(IProgressMonitor monitor, File dir) {
File dfsPath = new File(this.getPath().toString());
File destination = new File(dir, dfsPath.getName());
if (destination.exists()) {
boolean answer =
MessageDialog.openQuestion(null, "Overwrite existing local file?",
"The file you are attempting to download from the DFS "
+ this.getPath()
+ ", already exists in your local directory as "
+ destination + ".\n" + "Overwrite the existing file?");
if (!answer)
return;
}
try {
this.downloadToLocalFile(monitor, destination);
} catch (Exception e) {
e.printStackTrace();
MessageDialog.openWarning(null, "Download to local file system",
"Downloading of file \"" + this.path + "\" to local directory \""
+ dir + "\" has failed.\n" + e);
}
}
/**
* Provides a detailed string for this file
*
* @return the string formatted as
* <tt><filename> (<size>, r<replication>)</tt>
*/
public String toDetailedString() {
final String[] units = { "b", "Kb", "Mb", "Gb", "Tb" };
int unit = 0;
double l = this.length;
while ((l >= 1024.0) && (unit < units.length)) {
unit += 1;
l /= 1024.0;
}
return String.format("%s (%.1f %s, r%d)", super.toString(), l,
units[unit], this.replication);
}
/* @inheritDoc */
@Override
public String toString() {
return this.path.toString();
}
/*
*
*/
/**
* Download the DfsFile to a local file. Use the given monitor to report
* status of operation.
*
* @param monitor the status monitor
* @param file the local file where to put the downloaded file
* @throws InvocationTargetException
*/
public void downloadToLocalFile(IProgressMonitor monitor, File file)
throws InvocationTargetException {
final int taskSize = 1024;
monitor.setTaskName("Download file " + this.path);
BufferedOutputStream ostream = null;
DataInputStream istream = null;
try {
istream = getDFS().open(this.path);
ostream = new BufferedOutputStream(new FileOutputStream(file));
int bytes;
byte[] buffer = new byte[taskSize];
while ((bytes = istream.read(buffer)) >= 0) {
if (monitor.isCanceled())
return;
ostream.write(buffer, 0, bytes);
monitor.worked(1);
}
} catch (Exception e) {
throw new InvocationTargetException(e);
} finally {
// Clean all opened resources
if (istream != null) {
try {
istream.close();
} catch (IOException e) {
e.printStackTrace();
// nothing we can do here
}
}
try {
ostream.close();
} catch (IOException e) {
e.printStackTrace();
// nothing we can do here
}
}
}
/**
* Upload a local file to this file on the distributed file system
*
* @param monitor
* @param file
*/
public void upload(IProgressMonitor monitor, File file) {
final int taskSize = 1024;
monitor.setTaskName("Upload file " + this.path);
BufferedInputStream istream = null;
DataOutputStream ostream = null;
try {
istream = new BufferedInputStream(new FileInputStream(file));
ostream = getDFS().create(this.path);
int bytes;
byte[] buffer = new byte[taskSize];
while ((bytes = istream.read(buffer)) >= 0) {
if (monitor.isCanceled())
return;
ostream.write(buffer, 0, bytes);
monitor.worked(1);
}
} catch (Exception e) {
ErrorMessageDialog.display(String.format(
"Unable to uploade file %s to %s", file, this.path), e
.getLocalizedMessage());
} finally {
try {
if (istream != null)
istream.close();
} catch (IOException e) {
e.printStackTrace();
// nothing we can do here
}
try {
if (ostream != null)
ostream.close();
} catch (IOException e) {
e.printStackTrace();
// nothing we can do here
}
}
}
/* @inheritDoc */
@Override
public void refresh() {
getParent().refresh();
}
/* @inheritDoc */
@Override
public int computeDownloadWork() {
return 1 + (int) (this.length / 1024);
}
/**
* Creates an adapter for the file to open it in the Editor
*
* @return the IStorage
*/
public IStorage getIStorage() {
return new IStorageAdapter();
}
/**
* IStorage adapter to open the file in the Editor
*/
private class IStorageAdapter extends PlatformObject implements IStorage {
/* @inheritDoc */
public InputStream getContents() throws CoreException {
try {
return DFSFile.this.open();
} catch (IOException ioe) {
throw new CoreException(new Status(Status.ERROR,
Activator.PLUGIN_ID, 0, "Unable to open file \""
+ DFSFile.this.path + "\"", ioe));
}
}
/* @inheritDoc */
public IPath getFullPath() {
return new org.eclipse.core.runtime.Path(DFSFile.this.path.toString());
}
/* @inheritDoc */
public String getName() {
return DFSFile.this.path.getName();
}
/* @inheritDoc */
public boolean isReadOnly() {
return true;
}
}
/*
* Implementation of DFSContent
*/
/* @inheritDoc */
public DFSContent[] getChildren() {
return null;
}
/* @inheritDoc */
public boolean hasChildren() {
return false;
}
}