| /******************************************************************************* |
| * Copyright (c) 2018 Ericsson |
| * |
| * All rights reserved. This program and the accompanying materials are |
| * made available under the terms of the Eclipse Public License 2.0 which |
| * accompanies this distribution, and is available at |
| * https://www.eclipse.org/legal/epl-2.0/ |
| * |
| * SPDX-License-Identifier: EPL-2.0 |
| *******************************************************************************/ |
| package org.eclipse.tracecompass.tmf.core.io; |
| |
| import static org.eclipse.tracecompass.common.core.NonNullUtils.checkNotNull; |
| |
| import java.io.IOException; |
| import java.net.URI; |
| import java.nio.file.Files; |
| import java.nio.file.LinkOption; |
| import java.nio.file.Path; |
| import java.nio.file.Paths; |
| import java.util.Map; |
| import java.util.concurrent.atomic.AtomicReference; |
| |
| import org.eclipse.core.resources.IFile; |
| import org.eclipse.core.resources.IFolder; |
| import org.eclipse.core.resources.IResource; |
| import org.eclipse.core.resources.IWorkspace; |
| import org.eclipse.core.resources.IWorkspaceRoot; |
| import org.eclipse.core.resources.ResourcesPlugin; |
| import org.eclipse.core.runtime.CoreException; |
| import org.eclipse.core.runtime.ICoreRunnable; |
| import org.eclipse.core.runtime.IPath; |
| import org.eclipse.core.runtime.IProgressMonitor; |
| import org.eclipse.core.runtime.IStatus; |
| import org.eclipse.core.runtime.QualifiedName; |
| import org.eclipse.core.runtime.Status; |
| import org.eclipse.core.runtime.SubMonitor; |
| import org.eclipse.jdt.annotation.NonNullByDefault; |
| import org.eclipse.jdt.annotation.Nullable; |
| import org.eclipse.tracecompass.internal.tmf.core.Activator; |
| |
| /** |
| * Utility class for handling {@link IResource} instances. |
| * |
| * @author Bernd Hufmann |
| * @since 4.0 |
| */ |
| @NonNullByDefault |
| public class ResourceUtil { |
| |
| // ------------------------------------------------------------------------ |
| // Attributes |
| // ------------------------------------------------------------------------ |
| private static final boolean IS_WINDOWS = System.getProperty("os.name").contains("Windows"); //$NON-NLS-1$ //$NON-NLS-2$ |
| private static boolean fIsSymLinkSupported = !IS_WINDOWS; |
| |
| // ------------------------------------------------------------------------ |
| // Constructors |
| // ------------------------------------------------------------------------ |
| private ResourceUtil() { |
| // Do nothing |
| } |
| |
| // ------------------------------------------------------------------------ |
| // Operations |
| // ------------------------------------------------------------------------ |
| /** |
| * Creates a symbolic link to a target file or folder. If the local file system |
| * supports symbolic links and the user requests to use a file system link it |
| * will create a symbolic link on the file system. If the local file system |
| * doesn't support symbolic links or on Windows, it will always use Eclipse |
| * links. |
| * |
| * If a file system or Eclipse symbolic link already exists at the destination |
| * it will replace the existing link. If a file or folder exists at the |
| * destination the symbolic link won't be created and the method will return |
| * false. |
| * |
| * @param link |
| * the resource in the workspace representing the link |
| * @param targetLocation |
| * the target location in the local file system |
| * @param useFileSystemLinks |
| * true for using file system symbolic links, false for Eclipse links |
| * Note: If file system doesn't support symbolic links or on Windows |
| * Eclipse links will be used. |
| * @param monitor |
| * the progress monitor or null. |
| * @return <code>true</code> if link was created successfully, else |
| * <code>false</code> |
| * @throws CoreException |
| * if an error occurs |
| */ |
| public static boolean createSymbolicLink(IResource link, @Nullable IPath targetLocation, boolean useFileSystemLinks, @Nullable IProgressMonitor monitor) throws CoreException { |
| // Validate the input parameters |
| if (!(link instanceof IFile) && !(link instanceof IFolder) || targetLocation == null) { |
| return false; |
| } |
| |
| SubMonitor subMon = SubMonitor.convert(monitor, 3); |
| try { |
| IPath location = getLocation(link); |
| // Only create link if it doesn't already exist. |
| if ((location != null) && link.exists() && location.equals(targetLocation)) { |
| return true; |
| } |
| Path linkPath = Paths.get(link.getProject().getLocation().append(link.getProjectRelativePath()).toOSString()); |
| if (!checkResource(link, linkPath)) { |
| return false; |
| } |
| if (!fIsSymLinkSupported || !useFileSystemLinks) { |
| return createEclipseLink(link, targetLocation, subMon); |
| } |
| |
| String targetPathString = targetLocation.toOSString(); |
| Path targetPath = Paths.get(targetPathString); |
| |
| // if the target is a file system symbolic link |
| if (Files.isSymbolicLink(targetPath)) { |
| targetPath = Files.readSymbolicLink(targetPath); |
| } |
| // Create files system symbolic link |
| Files.createSymbolicLink(linkPath, targetPath); |
| subMon.worked(1); |
| if (link.getParent() != null) { |
| link.getParent().refreshLocal(IResource.DEPTH_ONE, subMon.split(1)); |
| } |
| link.refreshLocal(IResource.DEPTH_INFINITE, subMon.split(1)); |
| return true; |
| } catch (IOException e) { |
| throw new CoreException(new Status(IStatus.ERROR, Activator.PLUGIN_ID, "Error creating symbolic link", e)); //$NON-NLS-1$ |
| } catch (UnsupportedOperationException e) { |
| // Remember that the symbolic link creation is not supported |
| fIsSymLinkSupported = false; |
| // Use file system symbolic link |
| return createEclipseLink(link, targetLocation, subMon.split(2)); |
| } |
| } |
| |
| /** |
| * Deletes a resource from the file system. |
| * |
| * Notes: If the resource is a project, then the project will be deleted as well |
| * as the content on the file system. |
| * |
| * The resource of a broken file system symbolic link will be also deleted. |
| * |
| * @param resource |
| * the resource in the workspace. |
| * @param monitor |
| * the progress monitor or null. |
| * @throws CoreException |
| * if an error occurs |
| */ |
| public static void deleteResource(@Nullable IResource resource, @Nullable IProgressMonitor monitor) throws CoreException { |
| SubMonitor subMon = SubMonitor.convert(monitor, 1); |
| if (resource == null) { |
| return; |
| } |
| if (isFileSystemSymbolicLink(resource) && |
| !resource.exists() && |
| ((resource instanceof IFile) || |
| (resource instanceof IFolder))) { |
| // Broken link |
| try { |
| Path linkPath = Paths.get(resource.getProject().getLocation().append(resource.getProjectRelativePath()).toOSString()); |
| Files.delete(linkPath); |
| subMon.worked(1); |
| return; |
| } catch (IOException e) { |
| // do nothing ... try Resource.delete() below |
| } |
| } |
| resource.delete(true, subMon); |
| } |
| |
| /** |
| * Copy a resource in the file system. |
| * |
| * The supplied destination path may be absolute or relative. Absolute paths |
| * fully specify the new location for the resource relative to the workspace |
| * root, including its project. Relative paths are considered to be relative to |
| * the container of the resource being copied. |
| * |
| * @param resource |
| * the resource in the workspace |
| * @param destinationPath |
| * the destination path |
| * @param flags |
| * update flags according to IResource.copy(). Note for file system |
| * symbolic links only IResource.SHALLOW is supported |
| * @param monitor |
| * the progress monitor or null. |
| * @return the copied resource or null |
| * @throws CoreException |
| * if an error occurs |
| */ |
| public static @Nullable IResource copyResource(@Nullable IResource resource, @Nullable IPath destinationPath, int flags, @Nullable IProgressMonitor monitor) throws CoreException { |
| if (resource == null || destinationPath == null) { |
| return null; |
| } |
| SubMonitor subMon = SubMonitor.convert(monitor, 1); |
| IWorkspaceRoot workspaceRoot = ResourcesPlugin.getWorkspace().getRoot(); |
| boolean isFileSystemSymbolicLink = ResourceUtil.isFileSystemSymbolicLink(resource); |
| // make path absolute |
| IPath target = destinationPath.isAbsolute() ? destinationPath : resource.getParent().getFullPath().append(destinationPath); |
| if (isFileSystemSymbolicLink && |
| ((flags & IResource.SHALLOW) != 0) && |
| ((resource instanceof IFile) |
| || (resource instanceof IFolder))) { |
| return copySymlink(resource, checkNotNull(target), checkNotNull(subMon), checkNotNull(workspaceRoot)); |
| } |
| // use eclipse copy |
| resource.copy(destinationPath, flags, subMon); |
| return workspaceRoot.findMember(target); |
| } |
| |
| /** |
| * Checks whether the resource is a linked resource (file system or Eclipse |
| * symbolic link) regardless of link is broken or not. |
| * |
| * @param resource |
| * the resources to check |
| * @return <code>true</code> if it is a linked resource else <code>false</code> |
| */ |
| public static boolean isSymbolicLink(@Nullable IResource resource) { |
| boolean isLinked = false; |
| if (resource != null) { |
| isLinked = resource.isLinked(); |
| if (!isLinked) { |
| isLinked = isFileSystemSymbolicLink(resource); |
| } |
| } |
| return isLinked; |
| } |
| |
| /** |
| * Delete a broken symbolic link. Has no effect if the resource is not a |
| * symbolic link or if the target of the symbolic link exists. |
| * |
| * @param resource |
| * the resource in the workspace. |
| * @throws CoreException |
| * if an error occurs |
| */ |
| public static void deleteIfBrokenSymbolicLink(@Nullable IResource resource) throws CoreException { |
| if (resource == null) { |
| return; |
| } |
| if (resource.isLinked()) { |
| IPath location = resource.getLocation(); |
| if (location == null || !location.toFile().exists()) { |
| resource.delete(true, null); |
| } |
| } else { |
| URI uri = resource.getLocationURI(); |
| if (uri != null) { |
| Path linkPath = Paths.get(uri); |
| if (Files.isSymbolicLink(linkPath) && !resource.exists()) { |
| try { |
| Files.delete(linkPath); |
| } catch (Exception e) { |
| // Do nothing. |
| } |
| } |
| } |
| } |
| } |
| |
| /** |
| * Returns the location path of the given resource. If the resource is file |
| * system symbolic link then it will return the link target location. |
| * |
| * @param resource |
| * the resource to check |
| * @return the {@link IPath} of the resource or null |
| */ |
| public static @Nullable IPath getLocation(@Nullable IResource resource) { |
| URI locationUri = getLocationURI(resource); |
| if (locationUri != null) { |
| return new org.eclipse.core.runtime.Path(locationUri.getPath()); |
| } |
| return null; |
| } |
| |
| /** |
| * Returns the location URI of the given resource. If the resource is file |
| * system symbolic link then it will return the link target location. |
| * |
| * @param resource |
| * the resource to check |
| * @return the URI of the resource or null |
| */ |
| public static @Nullable URI getLocationURI(@Nullable IResource resource) { |
| if (resource != null) { |
| if (isFileSystemSymbolicLink(resource)) { |
| try { |
| return Files.readSymbolicLink(Paths.get(resource.getLocationURI())).toUri(); |
| } catch (IOException e) { |
| // Do nothing... return null below |
| } |
| } else { |
| return resource.getLocationURI(); |
| } |
| } |
| return null; |
| } |
| |
| // ------------------------------------------------------------------------ |
| // Helpers |
| // ------------------------------------------------------------------------ |
| private static boolean createEclipseLink(IResource link, IPath targetLocation, @Nullable IProgressMonitor monitor) throws CoreException { |
| SubMonitor subMon = SubMonitor.convert(monitor); |
| if (link instanceof IFile) { |
| ((IFile) link).createLink(targetLocation, IResource.REPLACE, subMon); |
| } else if (link instanceof IFolder) { |
| ((IFolder) link).createLink(targetLocation, IResource.REPLACE, subMon); |
| } |
| return true; |
| } |
| |
| private static boolean isFileSystemSymbolicLink(IResource resource) { |
| URI uri = resource.getLocationURI(); |
| return (uri == null ? false : Files.isSymbolicLink(Paths.get(uri))); |
| } |
| |
| private static boolean checkResource(IResource link, Path linkPath) throws CoreException, IOException { |
| if (link.exists()) { |
| // Eclipse resource already exists |
| if (link.isLinked() || |
| Files.isSymbolicLink(linkPath)) { |
| // Remove the link |
| link.delete(true, null); |
| } else { |
| // Abort because folder or file exists |
| return false; |
| } |
| } |
| if (Files.isSymbolicLink(linkPath)) { |
| // Delete the broken file system symbolic link |
| Files.delete(linkPath); |
| } else if (linkPath.toFile().exists()) { |
| // Abort because folder or file exists |
| return false; |
| } |
| return true; |
| } |
| |
| private static @Nullable IResource copySymlink(IResource resource, IPath destinationPath, SubMonitor monitor, IWorkspaceRoot workspaceRoot) throws CoreException { |
| AtomicReference<IResource> newResourceRef = new AtomicReference<>(); |
| Path originalLinkedFile = Paths.get(resource.getProject().getLocation().append(resource.getProjectRelativePath()).toOSString()); |
| IPath newLocation = workspaceRoot.findMember(destinationPath.segment(0)).getLocation().append(destinationPath.removeFirstSegments(1)); |
| Path newLinkedFile = Paths.get(newLocation.toOSString()); |
| IResource parent = workspaceRoot.findMember(destinationPath.removeLastSegments(1)); |
| if (parent == null) { |
| throw new CoreException(new Status(IStatus.ERROR, Activator.PLUGIN_ID, "Parent resource does not exist: " + destinationPath.removeLastSegments(1))); //$NON-NLS-1$ ) |
| } |
| ResourcesPlugin.getWorkspace().run((ICoreRunnable) (mon -> { |
| try { |
| SubMonitor subMon = SubMonitor.convert(mon, 2); |
| Files.copy(originalLinkedFile, newLinkedFile, LinkOption.NOFOLLOW_LINKS); |
| parent.refreshLocal(IResource.DEPTH_ONE, subMon.split(1)); |
| IResource newResource = workspaceRoot.findMember(destinationPath); |
| if (newResource == null) { |
| return; |
| } |
| newResource.refreshLocal(IResource.DEPTH_INFINITE, subMon.split(1)); |
| @SuppressWarnings("null") |
| Map<QualifiedName, String> persistentProperties = resource.getPersistentProperties(); |
| if (persistentProperties != null) { |
| for (Map.Entry<QualifiedName, String> entry : persistentProperties.entrySet()) { |
| newResource.setPersistentProperty(entry.getKey(), entry.getValue()); |
| } |
| } |
| newResourceRef.set(newResource); |
| } catch (IOException e) { |
| throw new CoreException(new Status(IStatus.ERROR, Activator.PLUGIN_ID, "Error copying symbolic link", e)); //$NON-NLS-1$ ) |
| } |
| }), parent.getParent(), IWorkspace.AVOID_UPDATE, monitor); |
| return newResourceRef.get(); |
| } |
| |
| } |
