xref: /dports/java/eclipse/eclipse.platform.releng.aggregator-R4_16/eclipse.jdt.core/org.eclipse.jdt.core/model/org/eclipse/jdt/internal/core/ExternalFoldersManager.java

/*******************************************************************************
 * Copyright (c) 2000, 2015 IBM Corporation and others.
 *
 * 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
 *
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *     Stephan Herrmann <stephan@cs.tu-berlin.de> - inconsistent initialization of classpath container backed by external class folder, see https://bugs.eclipse.org/320618
 *     Thirumala Reddy Mutchukota <thirumala@google.com> - Contribution to bug: https://bugs.eclipse.org/bugs/show_bug.cgi?id=411423
 *     Terry Parker <tparker@google.com> - [performance] Low hit rates in JavaModel caches - https://bugs.eclipse.org/421165
 *     Andrey Loskutov <loskutov@gmx.de> - ExternalFoldersManager.RefreshJob interrupts auto build job - https://bugs.eclipse.org/476059
 *******************************************************************************/
package org.eclipse.jdt.internal.core;

import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.nio.file.Files;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;
import java.util.concurrent.atomic.AtomicInteger;

import org.eclipse.core.resources.IFolder;
import org.eclipse.core.resources.IProject;
import org.eclipse.core.resources.IProjectDescription;
import org.eclipse.core.resources.IResource;
import org.eclipse.core.resources.IResourceStatus;
import org.eclipse.core.resources.IWorkspace;
import org.eclipse.core.resources.IWorkspaceRoot;
import org.eclipse.core.resources.ResourcesPlugin;
import org.eclipse.core.resources.WorkspaceJob;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IPath;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.MultiStatus;
import org.eclipse.core.runtime.Platform;
import org.eclipse.core.runtime.Status;
import org.eclipse.core.runtime.jobs.Job;
import org.eclipse.jdt.core.IClasspathEntry;
import org.eclipse.jdt.core.JavaCore;
import org.eclipse.jdt.core.JavaModelException;
import org.eclipse.jdt.internal.core.DeltaProcessor.RootInfo;
import org.eclipse.jdt.internal.core.util.Messages;
import org.eclipse.jdt.internal.core.util.Util;

public class ExternalFoldersManager {
	private static final boolean WINDOWS = System.getProperty("os.name").toLowerCase().contains("windows");  //$NON-NLS-1$//$NON-NLS-2$
	private static final String EXTERNAL_PROJECT_NAME = ".org.eclipse.jdt.core.external.folders"; //$NON-NLS-1$
	private static final String LINKED_FOLDER_NAME = ".link"; //$NON-NLS-1$
	private Map<IPath, IFolder> folders;
	private Set<IPath> pendingFolders; // subset of keys of 'folders', for which linked folders haven't been created yet.
	private final AtomicInteger counter = new AtomicInteger(0);
	/* Singleton instance */
	private static ExternalFoldersManager MANAGER;
	private RefreshJob refreshJob;

	private ExternalFoldersManager() {
		// Prevent instantiation
		// https://bugs.eclipse.org/bugs/show_bug.cgi?id=377806
		if (Platform.isRunning()) {
			/*
			 * The code here runs during JavaCore start-up.
			 * So if we need to open the external folders project, we do this from a job.
			 * Otherwise workspace jobs that attempt to access JDT core functionality can cause a deadlock.
			 *
			 * See https://bugs.eclipse.org/bugs/show_bug.cgi?id=542860.
			 */
			class InitializeFolders extends WorkspaceJob {
				public InitializeFolders() {
					super("Initialize external folders"); //$NON-NLS-1$
				}

				@Override
				public IStatus runInWorkspace(IProgressMonitor monitor) {
					getFolders();
					return Status.OK_STATUS;
				}

				@Override
				public boolean belongsTo(Object family) {
					return family == InitializeFolders.class;
				}
			}
			InitializeFolders initializeFolders = new InitializeFolders();
			IProject project = getExternalFoldersProject();
			initializeFolders.setRule(project);
			initializeFolders.schedule();
		}
	}

	public static synchronized ExternalFoldersManager getExternalFoldersManager() {
		if (MANAGER == null) {
			 MANAGER = new ExternalFoldersManager();
		}
		return MANAGER;
	}

	/**
	 * Returns a set of external paths to external folders referred to on the given classpath.
	 * Returns <code>null</code> if there are none.
	 */
	public static Set<IPath> getExternalFolders(IClasspathEntry[] classpath) {
		if (classpath == null)
			return null;
		Set<IPath> folders = null;
		for (int i = 0; i < classpath.length; i++) {
			IClasspathEntry entry = classpath[i];
			if (entry.getEntryKind() == IClasspathEntry.CPE_LIBRARY) {
				IPath entryPath = entry.getPath();
				if (isExternalFolderPath(entryPath)) {
					if (folders == null)
						folders = new LinkedHashSet<>();
					folders.add(entryPath);
				}
				IPath attachmentPath = entry.getSourceAttachmentPath();
				if (isExternalFolderPath(attachmentPath)) {
					if (folders == null)
						folders = new LinkedHashSet<>();
					folders.add(attachmentPath);
				}
			}
		}
		return folders;
	}

	/**
	 * Returns <code>true</code> if the provided path is a folder external to the project.
	 * The path is expected to be one matching the {@link IClasspathEntry#CPE_LIBRARY} case in
	 * {@link IClasspathEntry#getPath()} definition.
	 */
	public static boolean isExternalFolderPath(IPath externalPath) {
		if (externalPath == null || externalPath.isEmpty()) {
			return false;
		}

		JavaModelManager manager = JavaModelManager.getJavaModelManager();
		if (manager.isExternalFile(externalPath) || manager.isAssumedExternalFile(externalPath)) {
			return false;
		}
		if (!externalPath.isAbsolute()
				|| (WINDOWS && (externalPath.getDevice() == null && !externalPath.isUNC()))) {
			// can be only project relative path
			return false;
		}
		// Test if this an absolute path in local file system (not the workspace path)
		File externalFolder = externalPath.toFile();
		if (Files.isRegularFile(externalFolder.toPath())) {
			manager.addExternalFile(externalPath);
			return false;
		}
		if (Files.isDirectory(externalFolder.toPath())) {
			return true;
		}
		// this can be now only full workspace path or an external path to a not existing file or folder
		if (isInternalFilePath(externalPath)) {
			return false;
		}
		if (isInternalContainerPath(externalPath)) {
			return false;
		}
		// From here on the legacy code assumes that not existing resource must be external.
		// We just follow the old assumption.
		if (externalPath.getFileExtension() != null/*likely a .jar, .zip, .rar or other file*/) {
			manager.addAssumedExternalFile(externalPath);
			// assume not existing external (?) file (?) (can also be a folder with dotted name!)
			return false;
		}
		// assume not existing external (?) folder (?)
		return true;
	}

	/**
	 * @param path full absolute workspace path
	 */
	private static boolean isInternalFilePath(IPath path) {
		IWorkspaceRoot wsRoot = ResourcesPlugin.getWorkspace().getRoot();
		// in case this is full workspace path it should start with project segment
		if(path.segmentCount() > 1 && wsRoot.getFile(path).exists()) {
			return true;
		}
		return false;
	}

	/**
	 * @param path full absolute workspace path
	 */
	private static boolean isInternalContainerPath(IPath path) {
		IWorkspaceRoot wsRoot = ResourcesPlugin.getWorkspace().getRoot();
		// in case this is full workspace path it should start with project segment
		int segmentCount = path.segmentCount();
		if(segmentCount == 1 && wsRoot.getProject(path.segment(0)).exists()) {
			return true;
		}
		if(segmentCount > 1 && wsRoot.getFolder(path).exists()) {
			return true;
		}
		return false;
	}

	public static boolean isInternalPathForExternalFolder(IPath resourcePath) {
		return EXTERNAL_PROJECT_NAME.equals(resourcePath.segment(0));
	}

	public IFolder addFolder(IPath externalFolderPath, boolean scheduleForCreation) {
		return addFolder(externalFolderPath, getExternalFoldersProject(), scheduleForCreation);
	}

	private IFolder addFolder(IPath externalFolderPath, IProject externalFoldersProject, boolean scheduleForCreation) {
		Map<IPath, IFolder> knownFolders = getFolders();

		IFolder existing;
		synchronized (this) {
			existing = knownFolders.get(externalFolderPath);
			if (existing != null) {
				return existing;
			}
		}

		IFolder result;
		do {
			result = externalFoldersProject.getFolder(LINKED_FOLDER_NAME + this.counter.incrementAndGet());
		} while (result.exists());

		synchronized (this) {
			if (scheduleForCreation) {
				if (this.pendingFolders == null)
					this.pendingFolders = new LinkedHashSet<>();
				this.pendingFolders.add(externalFolderPath);
			}
			existing = knownFolders.get(externalFolderPath);
			if (existing != null) {
				return existing;
			}
			knownFolders.put(externalFolderPath, result);
		}
		return result;
	}

	/**
	 * Try to remove the argument from the list of folders pending for creation.
	 * @param externalPath to link to
	 * @return true if the argument was found in the list of pending folders and could be removed from it.
	 */
	public synchronized boolean removePendingFolder(Object externalPath) {
		if (this.pendingFolders == null)
			return false;
		return this.pendingFolders.remove(externalPath);
	}

	public IFolder createLinkFolder(IPath externalFolderPath, boolean refreshIfExistAlready, IProgressMonitor monitor) throws CoreException {
		IProject externalFoldersProject = createExternalFoldersProject(monitor); // run outside synchronized as this can create a resource
		return createLinkFolder(externalFolderPath, refreshIfExistAlready, externalFoldersProject, monitor);
	}

	private IFolder createLinkFolder(IPath externalFolderPath, boolean refreshIfExistAlready,
									IProject externalFoldersProject, IProgressMonitor monitor) throws CoreException {

		IFolder result = addFolder(externalFolderPath, externalFoldersProject, false);
		if (!result.exists()) {
			try {
				result.createLink(externalFolderPath, IResource.ALLOW_MISSING_LOCAL, monitor);
			} catch (CoreException e) {
				// If we managed to create the folder in the meantime, don't complain
				if (!result.exists()) {
					throw e;
				}
			}
		} else if (refreshIfExistAlready) {
			result.refreshLocal(IResource.DEPTH_INFINITE,  monitor);
		}
		return result;
	}

	public void createPendingFolders(IProgressMonitor monitor) throws JavaModelException{
		synchronized (this) {
			if (this.pendingFolders == null || this.pendingFolders.isEmpty()) return;
		}

		IProject externalFoldersProject = null;
		try {
			externalFoldersProject = createExternalFoldersProject(monitor);
		}
		catch(CoreException e) {
			throw new JavaModelException(e);
		}
		// https://bugs.eclipse.org/bugs/show_bug.cgi?id=368152
		// To avoid race condition (from addFolder and removeFolder, load the map elements into an array and clear the map immediately.
		// The createLinkFolder being in the synchronized block can cause a deadlock and hence keep it out of the synchronized block.
		Object[] arrayOfFolders = null;
		synchronized (this) {
			arrayOfFolders = this.pendingFolders.toArray();
			this.pendingFolders.clear();
		}

		for (int i=0; i < arrayOfFolders.length; i++) {
			try {
				createLinkFolder((IPath) arrayOfFolders[i], false, externalFoldersProject, monitor);
			} catch (CoreException e) {
				Util.log(e, "Error while creating a link for external folder :" + arrayOfFolders[i]); //$NON-NLS-1$
			}
		}
	}

	public void cleanUp(IProgressMonitor monitor) throws CoreException {
		List<Entry<IPath, IFolder>> toDelete = getFoldersToCleanUp(monitor);
		if (toDelete == null)
			return;
		for (Entry<IPath, IFolder> entry : toDelete) {
			IFolder folder = entry.getValue();
			folder.delete(true, monitor);
			IPath key = entry.getKey();
			this.folders.remove(key);
		}
		IProject project = getExternalFoldersProject();
		if (project.isAccessible() && project.members().length == 1/*remaining member is .project*/)
			project.delete(true, monitor);
	}

	private List<Entry<IPath, IFolder>> getFoldersToCleanUp(IProgressMonitor monitor) throws CoreException {
		DeltaProcessingState state = JavaModelManager.getDeltaState();
		Map<IPath, RootInfo> roots = state.roots;
		Map<IPath, IPath> sourceAttachments = state.sourceAttachments;
		if (roots == null && sourceAttachments == null)
			return null;
		Map<IPath, IFolder> knownFolders = getFolders();
		List<Entry<IPath, IFolder>> result = null;
		synchronized (knownFolders) {
			Iterator<Entry<IPath, IFolder>> iterator = knownFolders.entrySet().iterator();
			while (iterator.hasNext()) {
				Entry<IPath, IFolder> entry = iterator.next();
				IPath path = entry.getKey();
				if ((roots != null && !roots.containsKey(path))
						&& (sourceAttachments != null && !sourceAttachments.containsKey(path))) {
					if (entry.getValue() != null) {
						if (result == null)
							result = new ArrayList<>();
						result.add(entry);
					}
				}
			}
		}
		return result;
	}

	public IProject getExternalFoldersProject() {
		return ResourcesPlugin.getWorkspace().getRoot().getProject(EXTERNAL_PROJECT_NAME);
	}

	public IProject createExternalFoldersProject(IProgressMonitor monitor) throws CoreException {
		IProject project = getExternalFoldersProject();
		if (!project.isAccessible()) {
			if (!project.exists()) {
				createExternalFoldersProject(project, monitor);
			}
			openExternalFoldersProject(project, monitor);
		}
		return project;
	}

	/*
	 * Attempt to open the given project (assuming it exists).
	 * If failing to open, make all attempts to recreate the missing pieces.
	 */
	private void openExternalFoldersProject(IProject project, IProgressMonitor monitor) throws CoreException {
		try {
			project.open(monitor);
		} catch (CoreException e1) {
			if (e1.getStatus().getCode() == IResourceStatus.FAILED_READ_METADATA) {
				// workspace was moved
				// (see https://bugs.eclipse.org/bugs/show_bug.cgi?id=241400 and https://bugs.eclipse.org/bugs/show_bug.cgi?id=252571 )
				project.delete(false/*don't delete content*/, true/*force*/, monitor);
				createExternalFoldersProject(project, monitor);
			} else {
				// .project or folder on disk have been deleted, recreate them
				IPath stateLocation = JavaCore.getPlugin().getStateLocation();
				IPath projectPath = stateLocation.append(EXTERNAL_PROJECT_NAME);
				try {
					Files.createDirectories(projectPath.toFile().toPath());
					try (FileOutputStream output = new FileOutputStream(projectPath.append(".project").toOSString())){ //$NON-NLS-1$
				        output.write((
				        		"<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n" + //$NON-NLS-1$
				        		"<projectDescription>\n" + //$NON-NLS-1$
				        		"	<name>" + EXTERNAL_PROJECT_NAME + "</name>\n" + //$NON-NLS-1$ //$NON-NLS-2$
				        		"	<comment></comment>\n" + //$NON-NLS-1$
				        		"	<projects>\n" + //$NON-NLS-1$
				        		"	</projects>\n" + //$NON-NLS-1$
				        		"	<buildSpec>\n" + //$NON-NLS-1$
				        		"	</buildSpec>\n" + //$NON-NLS-1$
				        		"	<natures>\n" + //$NON-NLS-1$
				        		"	</natures>\n" + //$NON-NLS-1$
				        		"</projectDescription>").getBytes()); //$NON-NLS-1$
				    }
				} catch (IOException e) {
					// fallback to re-creating the project
					project.delete(false/*don't delete content*/, true/*force*/, monitor);
					createExternalFoldersProject(project, monitor);
				}
			}
			project.open(monitor);
		}
	}


	private void createExternalFoldersProject(IProject project, IProgressMonitor monitor) throws CoreException {
		IProjectDescription desc = project.getWorkspace().newProjectDescription(project.getName());
		IPath stateLocation = JavaCore.getPlugin().getStateLocation();
		desc.setLocation(stateLocation.append(EXTERNAL_PROJECT_NAME));
		try {
			project.create(desc, IResource.HIDDEN, monitor);
		} catch (CoreException e) {
			// If we managed to create the project in the meantime, don't complain
			if (!project.exists()) {
				throw e;
			}
		}
	}

	public IFolder getFolder(IPath externalFolderPath) {
		return getFolders().get(externalFolderPath);
	}

	Map<IPath, IFolder> getFolders() {
		if (this.folders == null) {
			Map<IPath, IFolder> tempFolders = new LinkedHashMap<>();
			IProject project = getExternalFoldersProject();
			try {
				if (!project.isAccessible()) {
					if (project.exists()) {
						// workspace was moved (see https://bugs.eclipse.org/bugs/show_bug.cgi?id=252571 )
						openExternalFoldersProject(project, null/*no progress*/);
					} else {
						// if project doesn't exist, do not open and recreate it as it means that there are no external folders
						return this.folders = Collections.synchronizedMap(tempFolders);
					}
				}
				IResource[] members = project.members();
				for (IResource member : members) {
					if (member.getType() == IResource.FOLDER && member.isLinked() && member.getName().startsWith(LINKED_FOLDER_NAME)) {
						IPath externalFolderPath = member.getLocation();
						tempFolders.put(externalFolderPath, (IFolder) member);
					}
				}
			} catch (CoreException e) {
				Util.log(e, "Exception while initializing external folders"); //$NON-NLS-1$
			}
			synchronized (this) {
				if (this.folders == null) {
					this.folders = Collections.synchronizedMap(tempFolders);
				}
			}
		}
		return this.folders;
	}

	// https://bugs.eclipse.org/bugs/show_bug.cgi?id=313153
	// Use the same RefreshJob if the job is still available
	private synchronized void runRefreshJob(Collection<IPath> paths) {
		if (paths == null || paths.isEmpty()) {
			return;
		}
		if (this.refreshJob == null) {
			this.refreshJob = new RefreshJob();
		}
		this.refreshJob.addFoldersToRefresh(paths);
	}

	/*
	 * Refreshes the external folders referenced on the classpath of the given source project
	 */
	public void refreshReferences(final IProject[] sourceProjects, IProgressMonitor monitor) {
		IProject externalProject = getExternalFoldersProject();
		try {
			Set<IPath> externalFolders = null;
			for (int index = 0; index < sourceProjects.length; index++) {
				if (sourceProjects[index].equals(externalProject))
					continue;
				if (!JavaProject.hasJavaNature(sourceProjects[index]))
					continue;

				Set<IPath> foldersInProject = getExternalFolders(((JavaProject) JavaCore.create(sourceProjects[index])).getResolvedClasspath());

				if (foldersInProject == null || foldersInProject.size() == 0)
					continue;
				if (externalFolders == null)
					externalFolders = new LinkedHashSet<>();

				externalFolders.addAll(foldersInProject);
			}
			runRefreshJob(externalFolders);

		} catch (CoreException e) {
			Util.log(e, "Exception while refreshing external project"); //$NON-NLS-1$
		}
	}

	public void refreshReferences(IProject source, IProgressMonitor monitor) {
		IProject externalProject = getExternalFoldersProject();
		if (source.equals(externalProject))
			return;
		if (!JavaProject.hasJavaNature(source))
			return;
		try {
			Set<IPath> externalFolders = getExternalFolders(((JavaProject) JavaCore.create(source)).getResolvedClasspath());
			runRefreshJob(externalFolders);
		} catch (CoreException e) {
			Util.log(e, "Exception while refreshing external project"); //$NON-NLS-1$
		}
	}

	public IFolder removeFolder(IPath externalFolderPath) {
		return getFolders().remove(externalFolderPath);
	}

	static class RefreshJob extends Job {

		final LinkedHashSet<IPath> externalFolders;

		RefreshJob(){
			super(Messages.refreshing_external_folders);
			// bug 476059: don't interrupt autobuild by using rule and system flag.
			setSystem(true);
			IWorkspace workspace = ResourcesPlugin.getWorkspace();
			setRule(workspace.getRuleFactory().refreshRule(workspace.getRoot()));
			this.externalFolders = new LinkedHashSet<>();
		}

		@Override
		public boolean belongsTo(Object family) {
			return family == ResourcesPlugin.FAMILY_MANUAL_REFRESH;
		}

		/*
		 * Add the collection of paths to be refreshed to the already
		 * existing set of paths and schedules the job
		 */
		public void addFoldersToRefresh(Collection<IPath> paths) {
			boolean shouldSchedule;
			synchronized (this.externalFolders) {
				this.externalFolders.addAll(paths);
				shouldSchedule = !this.externalFolders.isEmpty();
			}
			if (shouldSchedule) {
				schedule();
			}
		}

		@Override
		protected IStatus run(IProgressMonitor pm) {
			MultiStatus errors = new MultiStatus(JavaCore.PLUGIN_ID, IStatus.OK,
					"Exception while refreshing external folders", null); //$NON-NLS-1$
			while (true) {
				IPath externalPath;
				synchronized (this.externalFolders) {
					if (this.externalFolders.isEmpty()) {
						return errors.isOK()? Status.OK_STATUS : errors;
					}
					// keep the path in the list to avoid re-adding it while we are working
					externalPath = this.externalFolders.iterator().next();
				}

				try {
					IFolder folder = getExternalFoldersManager().getFolder(externalPath);
					// https://bugs.eclipse.org/bugs/show_bug.cgi?id=321358
					if (folder != null) {
						folder.refreshLocal(IResource.DEPTH_INFINITE, pm);
					}
				} catch (CoreException e) {
					errors.merge(e.getStatus());
				} finally {
					// we should always remove the path to avoid endless loop trying to refresh it
					synchronized (this.externalFolders) {
						this.externalFolders.remove(externalPath);
					}
				}
			}
		}
	}

}