| /******************************************************************************* |
| * Copyright (c) 2005, 2017 IBM Corporation and others. |
| * All rights reserved. This program and the accompanying materials |
| * are made available under the terms of the Eclipse Public License v1.0 |
| * which accompanies this distribution, and is available at |
| * http://www.eclipse.org/legal/epl-v10.html |
| * |
| * Contributors: |
| * IBM Corporation - initial API and implementation |
| *******************************************************************************/ |
| package org.eclipse.dltk.core.environment; |
| |
| import java.net.URI; |
| import java.util.ArrayList; |
| import java.util.Arrays; |
| import java.util.Collections; |
| import java.util.HashMap; |
| import java.util.List; |
| import java.util.Map; |
| |
| import org.eclipse.core.resources.IProject; |
| import org.eclipse.core.resources.IResource; |
| import org.eclipse.core.resources.IResourceChangeEvent; |
| import org.eclipse.core.resources.IResourceChangeListener; |
| import org.eclipse.core.resources.ResourcesPlugin; |
| import org.eclipse.core.runtime.CoreException; |
| import org.eclipse.core.runtime.IConfigurationElement; |
| import org.eclipse.core.runtime.IProgressMonitor; |
| import org.eclipse.core.runtime.ListenerList; |
| import org.eclipse.core.runtime.QualifiedName; |
| import org.eclipse.core.runtime.SubMonitor; |
| import org.eclipse.dltk.compiler.util.Util; |
| import org.eclipse.dltk.core.DLTKCore; |
| import org.eclipse.dltk.core.IModelElement; |
| import org.eclipse.dltk.core.IScriptProject; |
| import org.eclipse.dltk.core.ModelException; |
| import org.eclipse.dltk.core.internal.environment.LocalEnvironment; |
| import org.eclipse.dltk.internal.core.BuildpathValidation; |
| import org.eclipse.dltk.internal.core.ExternalScriptProject; |
| import org.eclipse.dltk.internal.core.ModelManager; |
| import org.eclipse.dltk.internal.core.ScriptProject; |
| import org.eclipse.dltk.utils.ExecutableOperation; |
| import org.eclipse.dltk.utils.ExecutionContexts; |
| import org.eclipse.dltk.utils.LazyExtensionManager; |
| import org.eclipse.dltk.utils.LazyExtensionManager.Descriptor; |
| import org.eclipse.osgi.util.NLS; |
| |
| public final class EnvironmentManager { |
| private static final QualifiedName PROJECT_ENVIRONMENT = new QualifiedName( |
| DLTKCore.PLUGIN_ID, "environment"); //$NON-NLS-1$ |
| |
| private static final String ENVIRONMENT_EXTENSION = DLTKCore.PLUGIN_ID |
| + ".environment"; //$NON-NLS-1$ |
| |
| private static class EnvironmentProviderManager |
| extends LazyExtensionManager<IEnvironmentProvider> { |
| |
| private static class EnvironmentProviderDesc |
| extends Descriptor<IEnvironmentProvider> { |
| private String id; |
| private int priority; |
| |
| public EnvironmentProviderDesc(EnvironmentProviderManager manager, |
| IConfigurationElement configurationElement) { |
| super(manager, configurationElement); |
| this.priority = parseInt( |
| configurationElement.getAttribute("priority")); //$NON-NLS-1$ |
| this.id = configurationElement.getAttribute("id"); //$NON-NLS-1$ |
| } |
| |
| public String getId() { |
| return id; |
| } |
| |
| } |
| |
| public EnvironmentProviderManager() { |
| super(ENVIRONMENT_EXTENSION); |
| } |
| |
| @Override |
| protected Descriptor<IEnvironmentProvider> createDescriptor( |
| IConfigurationElement confElement) { |
| return new EnvironmentProviderDesc(this, confElement); |
| } |
| |
| @Override |
| protected void initializeDescriptors( |
| List<Descriptor<IEnvironmentProvider>> descriptors) { |
| Collections.sort(descriptors, (arg0, arg1) -> { |
| EnvironmentProviderDesc d1 = (EnvironmentProviderDesc) arg0; |
| EnvironmentProviderDesc d2 = (EnvironmentProviderDesc) arg1; |
| return d1.priority - d2.priority; |
| }); |
| } |
| |
| } |
| |
| private static final EnvironmentProviderManager manager = new EnvironmentProviderManager(); |
| |
| private static ListenerList<IEnvironmentChangedListener> listeners = new ListenerList<>(); |
| |
| private static final Map<IProject, IEnvironment> environmentCache = new HashMap<>(); |
| |
| private static IResourceChangeListener resourceListener = event -> { |
| int eventType = event.getType(); |
| IResource resource = event.getResource(); |
| |
| switch (eventType) { |
| case IResourceChangeEvent.PRE_DELETE: |
| if (resource.getType() == IResource.PROJECT) { |
| synchronized (environmentCache) { |
| environmentCache.remove(resource); |
| } |
| } |
| return; |
| } |
| }; |
| |
| private EnvironmentManager() { |
| ResourcesPlugin.getWorkspace() |
| .addResourceChangeListener(resourceListener); |
| } |
| |
| /** |
| * Returns {@link IEnvironmentProvider} with the specified |
| * <code>providerId</code> or <code>null</code>. |
| * |
| * @since 2.0 |
| */ |
| public static IEnvironmentProvider getEnvironmentProvider( |
| String providerId) { |
| if (providerId != null) { |
| for (Descriptor<IEnvironmentProvider> descriptor : manager |
| .getDescriptors()) { |
| final EnvironmentProviderManager.EnvironmentProviderDesc desc = (EnvironmentProviderManager.EnvironmentProviderDesc) descriptor; |
| if (providerId.equals(desc.getId())) { |
| return desc.get(); |
| } |
| } |
| } |
| return null; |
| } |
| |
| public static IEnvironment getEnvironment(IModelElement element) { |
| if (element == null) { |
| return null; |
| } |
| IResource res = element.getResource(); |
| if (res != null && res.getType() != IResource.PROJECT) { |
| URI locationURI = res.getLocationURI(); |
| if (locationURI != null) { |
| for (IEnvironmentProvider provider : manager) { |
| waitInitialized(provider); |
| IEnvironment env = provider.getEnvironment(locationURI); |
| if (env != null) { |
| return env; |
| } |
| } |
| } |
| } |
| IScriptProject scriptProject = element.getScriptProject(); |
| if (scriptProject == null) { |
| return null; |
| } |
| IProject project = scriptProject.getProject(); |
| if (project == null) |
| return null; |
| |
| return getEnvironment(project); |
| } |
| |
| public static IEnvironment getEnvironment(IResource element) { |
| if (element == null) { |
| return null; |
| } |
| if (element.getType() != IResource.PROJECT) { |
| URI locationURI = element.getLocationURI(); |
| if (locationURI != null) { |
| for (IEnvironmentProvider provider : manager) { |
| waitInitialized(provider); |
| IEnvironment env = provider.getEnvironment(locationURI); |
| if (env != null) { |
| return env; |
| } |
| } |
| } |
| } |
| IProject project = element.getProject(); |
| if (project == null) |
| return null; |
| |
| return getEnvironment(project); |
| } |
| |
| public static IEnvironment getEnvironment(IProject project) { |
| synchronized (environmentCache) { |
| IEnvironment environment = environmentCache.get(project); |
| if (environment == null) { |
| if (!ExternalScriptProject.EXTERNAL_PROJECT_NAME |
| .equals(project.getName())) { |
| try { |
| final String environmentId = project |
| .getPersistentProperty(PROJECT_ENVIRONMENT); |
| if (environmentId != null) { |
| environment = getEnvironmentById(environmentId); |
| } |
| } catch (CoreException e) { |
| if (DLTKCore.DEBUG) { |
| e.printStackTrace(); |
| } |
| } |
| } |
| if (environment == null) { |
| environment = detectEnvironment(project); |
| } |
| environmentCache.put(project, environment); |
| } |
| return environment; |
| } |
| } |
| |
| /** |
| * @since 2.0 |
| */ |
| public static IEnvironment detectEnvironment(IProject project) { |
| for (IEnvironmentProvider provider : manager) { |
| waitInitialized(provider); |
| IEnvironment environment = provider.getProjectEnvironment(project); |
| if (environment != null) { |
| return environment; |
| } |
| } |
| return null; |
| } |
| |
| public static String getEnvironmentId(IProject project) { |
| return getEnvironmentId(project, true); |
| } |
| |
| public static String getEnvironmentId(IProject project, |
| boolean detectAutomatically) { |
| try { |
| final String environmentId = project |
| .getPersistentProperty(PROJECT_ENVIRONMENT); |
| if (environmentId != null) { |
| verifyEnvironmentCache(project, environmentId); |
| return environmentId; |
| } |
| } catch (CoreException e) { |
| if (DLTKCore.DEBUG) { |
| e.printStackTrace(); |
| } |
| } |
| if (detectAutomatically) { |
| final IEnvironment environment = detectEnvironment(project); |
| return environment != null ? environment.getId() : null; |
| } |
| return null; |
| } |
| |
| /** |
| * @param project |
| * @param environmentId |
| */ |
| private static void verifyEnvironmentCache(IProject project, |
| String environmentId) { |
| if (environmentId != null) { |
| synchronized (environmentCache) { |
| final IEnvironment environment = environmentCache.get(project); |
| if (environment != null |
| && !environmentId.equals(environment.getId())) { |
| environmentCache.remove(project); |
| } |
| } |
| } |
| } |
| |
| public static void setEnvironmentId(IProject project, String environmentId) |
| throws CoreException { |
| setEnvironmentId(project, environmentId, true); |
| } |
| |
| public static void setEnvironmentId(IProject project, String environmentId, |
| boolean refresh) throws CoreException { |
| synchronized (environmentCache) { |
| environmentCache.remove(project); |
| } |
| // TODO check project.getDescription.getLocationURI() scheme ? |
| project.setPersistentProperty(PROJECT_ENVIRONMENT, environmentId); |
| if (refresh) { |
| final IScriptProject scriptProject = DLTKCore.create(project); |
| if (scriptProject != null) { |
| DLTKCore.refreshBuildpathContainers(scriptProject); |
| new BuildpathValidation((ScriptProject) scriptProject) |
| .validate(); |
| } |
| } |
| } |
| |
| /** |
| * @since 2.0 |
| */ |
| public static void refreshBuildpathContainersForMixedProjects( |
| IProgressMonitor monitor) { |
| try { |
| SubMonitor subMonitor = SubMonitor.convert(monitor, 100); |
| final IScriptProject[] projects = ModelManager.getModelManager() |
| .getModel().getScriptProjects(); |
| subMonitor.worked(10); |
| subMonitor = subMonitor.newChild(90); |
| subMonitor.beginTask(Util.EMPTY_STRING, projects.length); |
| for (int i = 0; i < projects.length; i++) { |
| final IProject project = projects[i].getProject(); |
| final SubMonitor projectMonitor = subMonitor.newChild(1); |
| projectMonitor.beginTask(NLS.bind( |
| Messages.EnvironmentManager_RefreshProjectInterpreter, |
| project.getName()), 2); |
| final String environmentId = project |
| .getPersistentProperty(PROJECT_ENVIRONMENT); |
| if (environmentId != null) { |
| verifyEnvironmentCache(project, environmentId); |
| DLTKCore.refreshBuildpathContainers(projects[i]); |
| projectMonitor.worked(1); |
| new BuildpathValidation((ScriptProject) projects[i]) |
| .validate(); |
| projectMonitor.worked(1); |
| } |
| } |
| } catch (ModelException e) { |
| if (DLTKCore.DEBUG) { |
| e.printStackTrace(); |
| } |
| } catch (CoreException e) { |
| if (DLTKCore.DEBUG) { |
| e.printStackTrace(); |
| } |
| } finally { |
| monitor.done(); |
| } |
| } |
| |
| public static void setEnvironment(IProject project, |
| IEnvironment environment) throws CoreException { |
| setEnvironmentId(project, |
| environment != null ? environment.getId() : null); |
| } |
| |
| public static IEnvironment[] getEnvironments() { |
| return getEnvironments(true); |
| } |
| |
| public static IEnvironment[] getEnvironments(boolean allowWait) { |
| List<IEnvironment> envList = new ArrayList<>(); |
| for (IEnvironmentProvider provider : manager) { |
| if (allowWait) { |
| waitInitialized(provider); |
| } |
| envList.addAll(Arrays.asList(provider.getEnvironments())); |
| } |
| IEnvironment[] environments = new IEnvironment[envList.size()]; |
| envList.toArray(environments); |
| return environments; |
| } |
| |
| public static boolean isLocal(IEnvironment env) { |
| return LocalEnvironment.ENVIRONMENT_ID.equals(env.getId()); |
| } |
| |
| public static IEnvironment getEnvironmentById(String envId) { |
| for (IEnvironmentProvider provider : manager) { |
| waitInitialized(provider); |
| IEnvironment env = provider.getEnvironment(envId); |
| if (env != null) { |
| return env; |
| } |
| } |
| return null; |
| } |
| |
| public static void addEnvironmentChangedListener( |
| IEnvironmentChangedListener listener) { |
| listeners.add(listener); |
| } |
| |
| public static void removeEnvironmentChangedListener( |
| IEnvironmentChangedListener listener) { |
| listeners.remove(listener); |
| } |
| |
| public static void environmentAdded(IEnvironment environment) { |
| for (IEnvironmentChangedListener listener : listeners) { |
| listener.environmentAdded(environment); |
| } |
| fireEnvirontmentChange(); |
| } |
| |
| public static void environmentRemoved(IEnvironment environment) { |
| for (IEnvironmentChangedListener listener : listeners) { |
| listener.environmentRemoved(environment); |
| } |
| fireEnvirontmentChange(); |
| } |
| |
| public static void environmentChanged(IEnvironment environment) { |
| for (IEnvironmentChangedListener listener : listeners) { |
| listener.environmentChanged(environment); |
| } |
| fireEnvirontmentChange(); |
| } |
| |
| public static void fireEnvirontmentChange() { |
| for (IEnvironmentChangedListener listener : listeners) { |
| listener.environmentsModified(); |
| } |
| } |
| |
| public static IEnvironment getLocalEnvironment() { |
| return getEnvironmentById(LocalEnvironment.ENVIRONMENT_ID); |
| } |
| |
| /** |
| * Tests if all providers are initialized. |
| */ |
| public static boolean isInitialized() { |
| for (IEnvironmentProvider provider : manager) { |
| if (!provider.isInitialized()) { |
| return false; |
| } |
| } |
| return true; |
| } |
| |
| private static void waitInitialized(final IEnvironmentProvider provider) { |
| if (provider.isInitialized()) { |
| return; |
| } |
| ExecutionContexts.getManager() |
| .executeInBackground(new ExecutableOperation( |
| Messages.EnvironmentManager_initializingOperationName) { |
| @Override |
| public void execute(IProgressMonitor monitor) { |
| monitor.beginTask(Util.EMPTY_STRING, 1); |
| monitor.setTaskName(NLS.bind( |
| Messages.EnvironmentManager_initializingTaskName, |
| provider.getProviderName())); |
| provider.waitInitialized(); |
| monitor.worked(1); |
| monitor.done(); |
| } |
| }); |
| } |
| |
| /** |
| * Waits until all structures are initialized. |
| */ |
| public static void waitInitialized() { |
| waitInitialized((IProgressMonitor) null); |
| } |
| |
| public static void waitInitialized(IProgressMonitor monitor) { |
| if (monitor != null) { |
| monitor.beginTask(Util.EMPTY_STRING, |
| manager.getDescriptors().length); |
| } |
| for (IEnvironmentProvider provider : manager) { |
| if (monitor != null) { |
| monitor.setTaskName(NLS.bind( |
| Messages.EnvironmentManager_initializingTaskName, |
| provider.getProviderName())); |
| } |
| provider.waitInitialized(); |
| if (monitor != null) { |
| monitor.worked(1); |
| } |
| } |
| if (monitor != null) { |
| monitor.done(); |
| } |
| } |
| |
| private static class LocationResolverManager |
| extends LazyExtensionManager<IEnvironmentLocationResolver> { |
| |
| private static class Desc |
| extends Descriptor<IEnvironmentLocationResolver> { |
| private int priority; |
| |
| public Desc(LocationResolverManager manager, |
| IConfigurationElement configurationElement) { |
| super(manager, configurationElement); |
| this.priority = parseInt( |
| configurationElement.getAttribute("priority")); //$NON-NLS-1$ |
| } |
| |
| } |
| |
| private static final String LOCATION_RESOLVER_EXTENSION = DLTKCore.PLUGIN_ID |
| + ".locationResolver"; //$NON-NLS-1$ |
| |
| public LocationResolverManager() { |
| super(LOCATION_RESOLVER_EXTENSION); |
| } |
| |
| @Override |
| protected Descriptor<IEnvironmentLocationResolver> createDescriptor( |
| IConfigurationElement confElement) { |
| return new Desc(this, confElement); |
| } |
| |
| @Override |
| protected void initializeDescriptors( |
| List<Descriptor<IEnvironmentLocationResolver>> descriptors) { |
| Collections.sort(descriptors, (arg0, arg1) -> { |
| Desc d1 = (Desc) arg0; |
| Desc d2 = (Desc) arg1; |
| return d1.priority - d2.priority; |
| }); |
| } |
| } |
| |
| private static LocationResolverManager resolverManager = null; |
| |
| /** |
| * @since 2.0 |
| */ |
| public static URI[] resolve(URI location) { |
| if (resolverManager == null) { |
| resolverManager = new LocationResolverManager(); |
| } |
| final List<URI> result = new ArrayList<>(); |
| for (IEnvironmentLocationResolver resolver : resolverManager) { |
| final URI[] resolved = resolver.resolve(location); |
| if (resolved.length != 0) { |
| result.addAll(Arrays.asList(resolved)); |
| } |
| } |
| return result.toArray(new URI[result.size()]); |
| } |
| |
| } |
