public static File directoryOf(Class clazz) {
File location = locationOf(clazz);
if (location.isDirectory()) {
return location;
}
return location.getParentFile();
}
private void copy(File workspaceDir, InputStream in, Pattern glob, boolean overwrite)
throws Exception {
Jar jar = new Jar("dot", in);
try {
for (Entry<String, Resource> e : jar.getResources().entrySet()) {
String path = e.getKey();
bnd.trace("path %s", path);
if (glob != null && !glob.matcher(path).matches()) continue;
Resource r = e.getValue();
File dest = Processor.getFile(workspaceDir, path);
if (overwrite
|| !dest.isFile()
|| dest.lastModified() < r.lastModified()
|| r.lastModified() <= 0) {
bnd.trace("copy %s to %s", path, dest);
File dp = dest.getParentFile();
if (!dp.exists() && !dp.mkdirs()) {
throw new IOException("Could not create directory " + dp);
}
IO.copy(r.openInputStream(), dest);
}
}
} finally {
jar.close();
}
}
public String _dir(String args[]) {
if (args.length < 2) {
domain.warning("Need at least one file name for ${dir;...}");
return null;
}
String del = "";
StringBuilder sb = new StringBuilder();
for (int i = 1; i < args.length; i++) {
File f = domain.getFile(args[i]);
if (f.exists() && f.getParentFile().exists()) {
sb.append(del);
sb.append(f.getParentFile().getAbsolutePath());
del = ",";
}
}
return sb.toString();
}
public void init() throws IOException {
URL s = getClass().getClassLoader().getResource(SERVICE_JAR_FILE);
if (s == null)
if (underTest) return;
else throw new Error("No " + SERVICE_JAR_FILE + " resource in jar");
service.getParentFile().mkdirs();
IO.copy(s, service);
}
private void checkForGzippedVcf() {
String vcfName = finalVcf.getName();
if (vcfName.endsWith(".gz")) {
File uncomp = new File(finalVcf.getParentFile(), vcfName.substring(0, vcfName.length() - 3));
if (uncomp.exists() == false) {
deleteTempVcf = true;
if (IO.uncompress(finalVcf, uncomp) == null)
Misc.printErrAndExit("ERROR: failed to uncompress -> " + finalVcf);
}
finalVcf = uncomp;
}
}
@Nonnull
private static File getOutputFileCreatingDirIfNeeded(
@Nonnull String outputDir, @Nonnull String sourceFilePath) {
File outputFile = getOutputFile(outputDir, sourceFilePath);
File parentDir = outputFile.getParentFile();
if (!parentDir.exists()) {
boolean outputDirCreated = parentDir.mkdirs();
assert outputDirCreated : "Failed to create output dir: " + outputDir;
}
return outputFile;
}
/**
* Locate root path.
*
* @param root The user-specified root path.
*/
private void locateRoot(String root) {
// Locate default root folder.
if (root == null) {
File pwd = new File(".").getAbsoluteFile();
File f = pwd;
String[] l = null;
// Detect intl-style/xxx/htdocs by finding "js" and "css" in sub folders.
do {
f = f.getParentFile();
if (f == null) {
break;
}
l =
f.list(
new FilenameFilter() {
private Pattern pattern = Pattern.compile("^(?:js|css)$");
public boolean accept(File dir, String name) {
return pattern.matcher(name).matches();
}
});
} while (l.length != 2);
// If present, use intl-style/xxx/htdocs as root folder for Alibaba.
if (f != null) {
this.root = canonize(f);
// Else use present working folder as root folder.
} else {
this.root = canonize(pwd);
}
// Use user-specified root folder.
} else {
File f = new File(root);
if (f.exists()) {
this.root = canonize(f);
} else {
App.exit("The user-specified root folder " + root + " does not exist.");
}
}
}
public void _workspace(WorkspaceOptions opts) throws Exception {
File base = bnd.getBase();
String name = opts._arguments().get(0);
File workspaceDir = Processor.getFile(base, name);
name = workspaceDir.getName();
base = workspaceDir.getParentFile();
if (base == null) {
bnd.error(
"You cannot create a workspace in the root (%s). The parent of a workspace %n"
+ "must be a valid directory. Recommended is to dedicate a directory to %n"
+ "all (or related) workspaces.",
workspaceDir);
return;
}
if (!opts.anyname() && !Verifier.isBsn(name)) {
bnd.error(
"You specified a workspace name that does not follow the recommended pattern "
+ "(it should be like a Bundle Symbolic name). It is a bit pedantic but it "
+ "really helps hwne you get many workspaces. If you insist on this name, use the -a/--anyname option.");
return;
}
Workspace ws = bnd.getWorkspace((File) null);
if (ws != null && ws.isValid()) {
bnd.error(
"You are currently in a workspace already (%s) in %s. You can only create a new workspace outside an existing workspace",
ws, base);
return;
}
File eclipseDir = workspaceDir;
workspaceDir.mkdirs();
if (!opts.single()) workspaceDir = new File(workspaceDir, "scm");
workspaceDir.mkdirs();
if (!base.isDirectory()) {
bnd.error("Could not create directory for the bnd workspace %s", base);
} else if (!eclipseDir.isDirectory()) {
bnd.error("Could not create directory for the Eclipse workspace %s", eclipseDir);
}
if (!workspaceDir.isDirectory()) {
bnd.error("Could not create the workspace directory %s", workspaceDir);
return;
}
if (!opts.update() && !opts.force() && workspaceDir.list().length > 0) {
bnd.error(
"The workspace directory %s is not empty, specify -u/--update to update or -f/--force to replace",
workspaceDir);
}
InputStream in = getClass().getResourceAsStream("/templates/enroute.zip");
if (in == null) {
bnd.error("Cannot find template in this jar %s", "/templates/enroute.zip");
return;
}
Pattern glob = Pattern.compile("[^/]+|cnf/.*|\\...+/.*");
copy(workspaceDir, in, glob, opts.force());
File readme = new File(workspaceDir, "README.md");
if (readme.isFile()) IO.copy(readme, bnd.out);
bnd.out.printf(
"%nWorkspace %s created.%n%n" //
+ " Start Eclipse:%n" //
+ " 1) Select the Eclipse workspace %s%n" //
+ " 2) Package Explorer context menu: Import/General/Existing Projects from %s%n"
+ "%n"
+ "", //
workspaceDir.getName(), eclipseDir, workspaceDir);
}
public void actionPerformed(ActionEvent e) {
if (isDirectorySelected()) {
File dir = getDirectory();
if (dir != null) {
try {
// Strip trailing ".."
dir = ShellFolder.getNormalizedFile(dir);
} catch (IOException ex) {
// Ok, use f as is
}
changeDirectory(dir);
return;
}
}
JFileChooser chooser = getFileChooser();
String filename = getFileName();
FileSystemView fs = chooser.getFileSystemView();
File dir = chooser.getCurrentDirectory();
if (filename != null) {
// Remove whitespaces from end of filename
int i = filename.length() - 1;
while (i >= 0 && filename.charAt(i) <= ' ') {
i--;
}
filename = filename.substring(0, i + 1);
}
if (filename == null || filename.length() == 0) {
// no file selected, multiple selection off, therefore cancel the approve action
resetGlobFilter();
return;
}
File selectedFile = null;
File[] selectedFiles = null;
// Unix: Resolve '~' to user's home directory
if (File.separatorChar == '/') {
if (filename.startsWith("~/")) {
filename = System.getProperty("user.home") + filename.substring(1);
} else if (filename.equals("~")) {
filename = System.getProperty("user.home");
}
}
if (chooser.isMultiSelectionEnabled()
&& filename.length() > 1
&& filename.charAt(0) == '"'
&& filename.charAt(filename.length() - 1) == '"') {
List<File> fList = new ArrayList<File>();
String[] files = filename.substring(1, filename.length() - 1).split("\" \"");
// Optimize searching files by names in "children" array
Arrays.sort(files);
File[] children = null;
int childIndex = 0;
for (String str : files) {
File file = fs.createFileObject(str);
if (!file.isAbsolute()) {
if (children == null) {
children = fs.getFiles(dir, false);
Arrays.sort(children);
}
for (int k = 0; k < children.length; k++) {
int l = (childIndex + k) % children.length;
if (children[l].getName().equals(str)) {
file = children[l];
childIndex = l + 1;
break;
}
}
}
fList.add(file);
}
if (!fList.isEmpty()) {
selectedFiles = fList.toArray(new File[fList.size()]);
}
resetGlobFilter();
} else {
selectedFile = fs.createFileObject(filename);
if (!selectedFile.isAbsolute()) {
selectedFile = fs.getChild(dir, filename);
}
// check for wildcard pattern
FileFilter currentFilter = chooser.getFileFilter();
if (!selectedFile.exists() && isGlobPattern(filename)) {
changeDirectory(selectedFile.getParentFile());
if (globFilter == null) {
globFilter = new GlobFilter();
}
try {
globFilter.setPattern(selectedFile.getName());
if (!(currentFilter instanceof GlobFilter)) {
actualFileFilter = currentFilter;
}
chooser.setFileFilter(null);
chooser.setFileFilter(globFilter);
return;
} catch (PatternSyntaxException pse) {
// Not a valid glob pattern. Abandon filter.
}
}
resetGlobFilter();
// Check for directory change action
boolean isDir = (selectedFile != null && selectedFile.isDirectory());
boolean isTrav = (selectedFile != null && chooser.isTraversable(selectedFile));
boolean isDirSelEnabled = chooser.isDirectorySelectionEnabled();
boolean isFileSelEnabled = chooser.isFileSelectionEnabled();
boolean isCtrl =
(e != null
&& (e.getModifiers() & Toolkit.getDefaultToolkit().getMenuShortcutKeyMask()) != 0);
if (isDir && isTrav && (isCtrl || !isDirSelEnabled)) {
changeDirectory(selectedFile);
return;
} else if ((isDir || !isFileSelEnabled)
&& (!isDir || !isDirSelEnabled)
&& (!isDirSelEnabled || selectedFile.exists())) {
selectedFile = null;
}
}
if (selectedFiles != null || selectedFile != null) {
if (selectedFiles != null || chooser.isMultiSelectionEnabled()) {
if (selectedFiles == null) {
selectedFiles = new File[] {selectedFile};
}
chooser.setSelectedFiles(selectedFiles);
// Do it again. This is a fix for bug 4949273 to force the
// selected value in case the ListSelectionModel clears it
// for non-existing file names.
chooser.setSelectedFiles(selectedFiles);
} else {
chooser.setSelectedFile(selectedFile);
}
chooser.approveSelection();
} else {
if (chooser.isMultiSelectionEnabled()) {
chooser.setSelectedFiles(null);
} else {
chooser.setSelectedFile(null);
}
chooser.cancelSelection();
}
}
/**
* Method to move files from HDFS to local filesystem
*
* <p>localPath: Path on the machines filesystem fs:FileSystem object from HDFS pathList:List of
* paths for files that might need to be backed up size:max size in bytes to be backed up
*
* <p>ReturnsDate of the last files backed up if reached size limit, else, zero
*/
public long backupFiles(
String localPath, String preservePath, FileSystem fs, ArrayList<Path> pathList, long size) {
Path fsPath;
long tmpSize = 0;
long tmpDate = 0;
// Start iterating over all paths
for (Path hdfsPath : pathList) {
try {
long nFileSize = fs.getContentSummary(hdfsPath).getLength();
tmpSize = tmpSize + nFileSize;
if ((tmpSize <= size) || (size == 0)) {
FileStatus stat = fs.getFileStatus(hdfsPath);
System.err.println(
"File "
+ hdfsPath.toUri().getPath()
+ " "
+ nFileSize
+ " bytes, "
+ "perms: "
+ stat.getOwner()
+ "/"
+ stat.getGroup()
+ ", "
+ stat.getPermission().toString());
tmpDate = stat.getModificationTime() / 1000;
String sFsPath = localPath + hdfsPath.toUri().getPath();
fsPath = new Path(sFsPath);
File f = new File(sFsPath);
// COMMENTED OUT: until a few backup cycles run
// and the mtime gets in fact set on all copied
// files.
//
// ignore it if the file exists and has the same mtime
// if (f.exists() && f.isFile() && f.lastModified() == stat.getModificationTime())
// {
// System.out.println("no need to backup " + f.toString() + ", mtime matches hdfs");
// continue;
// }
if (false == m_bDryRun) {
// check if we need to back up the local file
// (not directory), if it already exists.
if (f.exists() && f.isFile()) {
// ignore files with substrings in the
// no-preserve file
if (true == doPreserveFile(sFsPath)) {
// move it to the backup path
String sNewPath = preservePath + hdfsPath.toUri().getPath();
File newFile = new File(sNewPath);
// create directory structure for new file?
if (false == newFile.getParentFile().exists()) {
if (false == newFile.getParentFile().mkdirs()) {
System.err.println("Failed to mkdirs " + newFile.getParentFile().toString());
System.exit(1);
}
}
// rename existing file to new location
if (false == f.renameTo(newFile)) {
System.err.println(
"Failed to renameTo " + f.toString() + " to " + newFile.toString());
System.exit(1);
}
System.out.println("preserved " + f.toString() + " into " + newFile.toString());
} else {
System.out.println("skipped preservation of " + f.toString());
}
}
// copy from hdfs to local filesystem
fs.copyToLocalFile(hdfsPath, fsPath);
// set the mtime to match hdfs file
f.setLastModified(stat.getModificationTime());
// compare checksums on both files
compareChecksums(fs, hdfsPath, sFsPath);
}
// don't print the progress after every file -- go
// by at least 1% increments
long nPercentDone = (long) (100 * tmpSize / m_nTotalBytes);
if (nPercentDone > m_nLastPercentBytesDone) {
System.out.println(
"progress: copied "
+ prettyPrintBytes(tmpSize)
+ ", "
+ nPercentDone
+ "% done"
+ ", tstamp="
+ tmpDate);
m_nLastPercentBytesDone = nPercentDone;
}
if (m_nSleepSeconds > 0) {
try {
Thread.sleep(1000 * m_nSleepSeconds);
} catch (Exception e2) {
// ignore
}
}
} else {
return tmpDate;
}
} catch (IOException e) {
System.err.println("FATAL ERROR: Something wrong with the file");
System.err.println(e);
System.out.println(tmpDate);
System.exit(1);
return 0;
}
}
return 0;
}