| package org.eclipse.dltk.tcl.core; |
| |
| import java.io.ByteArrayInputStream; |
| import java.io.File; |
| import java.io.IOException; |
| import java.io.StringReader; |
| import java.util.ArrayList; |
| import java.util.Collections; |
| import java.util.Date; |
| import java.util.HashMap; |
| import java.util.HashSet; |
| import java.util.Iterator; |
| import java.util.List; |
| import java.util.Map; |
| import java.util.Set; |
| |
| import javax.xml.parsers.DocumentBuilder; |
| import javax.xml.parsers.DocumentBuilderFactory; |
| import javax.xml.parsers.ParserConfigurationException; |
| |
| import org.eclipse.core.runtime.CoreException; |
| import org.eclipse.core.runtime.IPath; |
| import org.eclipse.core.runtime.IProgressMonitor; |
| import org.eclipse.core.runtime.Platform; |
| import org.eclipse.dltk.core.DLTKCore; |
| import org.eclipse.dltk.core.ProgressMonitoringJob; |
| import org.eclipse.dltk.core.RuntimePerformanceMonitor; |
| import org.eclipse.dltk.core.RuntimePerformanceMonitor.PerformanceNode; |
| import org.eclipse.dltk.core.environment.IDeployment; |
| import org.eclipse.dltk.core.environment.IEnvironment; |
| import org.eclipse.dltk.core.environment.IExecutionEnvironment; |
| import org.eclipse.dltk.core.environment.IFileHandle; |
| import org.eclipse.dltk.launching.EnvironmentVariable; |
| import org.eclipse.dltk.launching.IInterpreterInstall; |
| import org.eclipse.dltk.launching.IInterpreterInstallChangedListener; |
| import org.eclipse.dltk.launching.InterpreterConfig; |
| import org.eclipse.dltk.launching.InterpreterStandin; |
| import org.eclipse.dltk.launching.PropertyChangeEvent; |
| import org.eclipse.dltk.launching.ScriptLaunchUtil; |
| import org.eclipse.dltk.launching.ScriptRuntime; |
| import org.eclipse.dltk.tcl.core.packages.TclInterpreterInfo; |
| import org.eclipse.dltk.tcl.core.packages.TclModuleInfo; |
| import org.eclipse.dltk.tcl.core.packages.TclPackageInfo; |
| import org.eclipse.dltk.tcl.core.packages.TclPackagesFactory; |
| import org.eclipse.dltk.tcl.core.packages.TclPackagesPackage; |
| import org.eclipse.dltk.tcl.core.packages.TclProjectInfo; |
| import org.eclipse.dltk.tcl.core.packages.VariableMap; |
| import org.eclipse.dltk.tcl.core.packages.VariableValue; |
| import org.eclipse.dltk.tcl.internal.core.packages.ProcessOutputCollector; |
| import org.eclipse.emf.common.util.BasicEMap; |
| import org.eclipse.emf.common.util.ECollections; |
| import org.eclipse.emf.common.util.EList; |
| import org.eclipse.emf.common.util.EMap; |
| import org.eclipse.emf.common.util.URI; |
| import org.eclipse.emf.ecore.EObject; |
| import org.eclipse.emf.ecore.resource.Resource; |
| import org.eclipse.emf.ecore.util.EcoreUtil; |
| import org.eclipse.emf.ecore.xmi.impl.XMIResourceImpl; |
| import org.eclipse.osgi.util.NLS; |
| import org.w3c.dom.Document; |
| import org.w3c.dom.Element; |
| import org.w3c.dom.Node; |
| import org.w3c.dom.NodeList; |
| import org.xml.sax.InputSource; |
| import org.xml.sax.SAXException; |
| import org.xml.sax.helpers.DefaultHandler; |
| |
| public class TclPackagesManager { |
| private static final String DLTK_TCL = "scripts/dltk.tcl"; //$NON-NLS-1$ |
| public static final String END_OF_STREAM = "DLTK-TCL-HELPER-9E7A168E-5EEF-4a46-A86D-0C82E90686E4-END-OF-STREAM"; //$NON-NLS-1$ |
| private static final String PKG_VERSION = "v20090505"; //$NON-NLS-1$ |
| |
| private static Resource infos = null; |
| private static final Map<String, Resource> projectInfos = new HashMap<String, Resource>(); |
| |
| private static IInterpreterInstallChangedListener installChangedListener = null; |
| private static Set<IInterpreterInstall> packageFetchingSet = new HashSet<IInterpreterInstall>(); |
| private static Set<IInterpreterInstall> sourcesFetchingSet = new HashSet<IInterpreterInstall>(); |
| |
| public static List<TclPackageInfo> getPackageInfos( |
| IInterpreterInstall install, Set<String> packageNames, |
| boolean fetchIfRequired) { |
| initialize(); |
| TclInterpreterInfo interpreterInfo = getTclInterpreter(install); |
| List<TclPackageInfo> collection; |
| synchronized (TclPackagesManager.class) { |
| collection = Collections |
| .unmodifiableList(getPackagesForInterpreter(packageNames, |
| fetchIfRequired, interpreterInfo, install)); |
| } |
| return collection; |
| } |
| |
| public static List<TclPackageInfo> getPackageInfos( |
| IInterpreterInstall install) { |
| initialize(); |
| TclInterpreterInfo interpreterInfo = getTclInterpreter(install); |
| List<TclPackageInfo> collection = null; |
| synchronized (TclPackagesManager.class) { |
| collection = Collections |
| .unmodifiableList(new ArrayList<TclPackageInfo>( |
| interpreterInfo.getPackages())); |
| } |
| return collection; |
| } |
| |
| public static TclPackageInfo getPackageInfo(IInterpreterInstall install, |
| String name, boolean fetchIfRequired) { |
| initialize(); |
| TclInterpreterInfo interpreterInfo = getTclInterpreter(install); |
| EList<TclPackageInfo> packages = interpreterInfo.getPackages(); |
| Set<TclPackageInfo> toFetch = new HashSet<TclPackageInfo>(); |
| TclPackageInfo result = null; |
| |
| synchronized (TclPackagesManager.class) { |
| for (TclPackageInfo tclPackageInfo : packages) { |
| if (name.equals(tclPackageInfo.getName())) { |
| if (tclPackageInfo.isFetched() || !fetchIfRequired) { |
| return tclPackageInfo; |
| } else { |
| toFetch.add(tclPackageInfo); |
| fetchSources(toFetch, install, interpreterInfo, null); |
| result = tclPackageInfo; |
| break; |
| } |
| } |
| } |
| } |
| return result; |
| } |
| |
| public static Set<TclPackageInfo> getDependencies( |
| IInterpreterInstall install, String name, boolean fetchIfRequired) { |
| initialize(); |
| TclPackageInfo info = getPackageInfo(install, name, fetchIfRequired); |
| if (info != null) { |
| Set<TclPackageInfo> result = new HashSet<TclPackageInfo>(); |
| Set<TclPackageInfo> toFetch = new HashSet<TclPackageInfo>(); |
| processPackage(info, result, toFetch, fetchIfRequired); |
| if (toFetch.size() > 0) { |
| TclInterpreterInfo interpreter = getTclInterpreter(install); |
| fetchSources(toFetch, install, interpreter, null); |
| processPackage(info, result, toFetch, fetchIfRequired); |
| } |
| result.remove(info); |
| return result; |
| } |
| return null; |
| } |
| |
| private static TclInterpreterInfo getTclInterpreter( |
| IInterpreterInstall install) { |
| return getTclInterpreter(install, true); |
| } |
| |
| /** |
| * @since 2.0 |
| * @param install |
| * @return |
| */ |
| public static long getTclInterpreterFetchDate(IInterpreterInstall install) { |
| TclInterpreterInfo interpreter = getTclInterpreter(install, true); |
| if (interpreter != null) { |
| return interpreter.getFetchedAt().getTime(); |
| } |
| return 0; |
| } |
| |
| private static TclInterpreterInfo getTclInterpreter( |
| IInterpreterInstall install, boolean allowCreate) { |
| TclInterpreterInfo interpreterInfo = null; |
| String interpreterLocation = install.getInstallLocation().getPath() |
| .toString(); |
| String environmentId = install.getInstallLocation().getEnvironmentId(); |
| synchronized (TclPackagesManager.class) { |
| for (EObject eObject : infos.getContents()) { |
| if (eObject instanceof TclInterpreterInfo) { |
| TclInterpreterInfo info = (TclInterpreterInfo) eObject; |
| String location = info.getInstallLocation(); |
| String name = info.getName(); |
| String env = info.getEnvironment(); |
| if (interpreterLocation.equals(location) |
| && install.getName().equals(name) && env != null |
| && env.equals(environmentId)) { |
| interpreterInfo = info; |
| break; |
| } |
| } |
| } |
| if (interpreterInfo == null) { |
| if (!allowCreate) { |
| return null; |
| } |
| interpreterInfo = TclPackagesFactory.eINSTANCE |
| .createTclInterpreterInfo(); |
| interpreterInfo.setInstallLocation(interpreterLocation); |
| interpreterInfo.setName(install.getName()); |
| interpreterInfo.setEnvironment(environmentId); |
| interpreterInfo.setFetched(false); |
| infos.getContents().add(interpreterInfo); |
| } |
| } |
| fetchPackagesForInterpreter(install, interpreterInfo); |
| |
| return interpreterInfo; |
| } |
| |
| private static long getPackagesRefreshInterval(IInterpreterInstall install) { |
| if (install == null) { |
| return 0; |
| } |
| final String refreshIntervalKey; |
| final IEnvironment environment = install.getEnvironment(); |
| if (environment != null && environment.isLocal()) { |
| refreshIntervalKey = TclCorePreferences.PACKAGES_REFRESH_INTERVAL_LOCAL; |
| } else { |
| refreshIntervalKey = TclCorePreferences.PACKAGES_REFRESH_INTERVAL_REMOTE; |
| } |
| return Platform.getPreferencesService().getLong(TclPlugin.PLUGIN_ID, |
| refreshIntervalKey, 15 * 60 * 1000, null); |
| } |
| |
| public static TclProjectInfo getTclProject(String name) { |
| Resource resource = getProjectInfoResource(name); |
| synchronized (resource) { |
| TclProjectInfo info = null; |
| for (EObject eObject : resource.getContents()) { |
| if (eObject instanceof TclProjectInfo) { |
| TclProjectInfo pinfo = (TclProjectInfo) eObject; |
| String pname = pinfo.getName(); |
| if (name != null && name.equals(pname)) { |
| info = pinfo; |
| } |
| } |
| } |
| if (info == null) { |
| info = TclPackagesFactory.eINSTANCE.createTclProjectInfo(); |
| info.setName(name); |
| resource.getContents().add(info); |
| } |
| return info; |
| } |
| } |
| |
| private static void fetchPackagesForInterpreter( |
| IInterpreterInstall install, TclInterpreterInfo interpreterInfo) { |
| synchronized (TclPackagesManager.class) { |
| while (packageFetchingSet.contains(install)) { |
| // White until it will be removed from fetches list |
| try { |
| TclPackagesManager.class.wait(50); |
| } catch (InterruptedException e) { |
| TclPlugin.error(e); |
| } |
| } |
| if (!(!interpreterInfo.isFetched() |
| || interpreterInfo.getFetchedAt() == null || interpreterInfo |
| .getFetchedAt().getTime() |
| + getPackagesRefreshInterval(install) < System |
| .currentTimeMillis())) { |
| return; // Info already fetched and ok |
| } |
| packageFetchingSet.add(install); |
| } |
| try { |
| PerformanceNode p = RuntimePerformanceMonitor.begin(); |
| IExecutionEnvironment exeEnv = install.getExecEnvironment(); |
| if (exeEnv == null) { |
| return; |
| } |
| ProgressMonitoringJob monitor = new ProgressMonitoringJob( |
| Messages.TclInterpreterMessages_RetrieveListOfAvailablePackages |
| + " " + install.getName(), 100); |
| try { |
| List<String> content = deployExecute(exeEnv, install, |
| new String[] { "get-pkgs" }, install //$NON-NLS-1$ |
| .getEnvironmentVariables(), monitor); |
| synchronized (TclPackagesManager.class) { |
| if (content != null) { |
| /* Progress monitoring */monitor |
| .subTask(Messages.TclInterpreterMessages_ProcessingPackagesInfo); |
| processContent(content, false, true, interpreterInfo); |
| /* Progress monitoring */monitor.worked(20); |
| interpreterInfo.setFetched(true); |
| interpreterInfo.setFetchedAt(new Date()); |
| monitor |
| .subTask(Messages.TclInterpreterMessages_SavePackagesInfo); |
| save(); |
| monitor.worked(10); |
| } |
| } |
| String msg = Messages.TclInterpreterMessages_FetchInterpreterPackagesInfo; |
| p.done("Tcl", msg, 0); //$NON-NLS-1$ |
| } finally { |
| monitor.done(); |
| } |
| } finally { |
| synchronized (TclPackagesManager.class) { |
| packageFetchingSet.remove(install); |
| TclPackagesManager.class.notifyAll(); |
| } |
| } |
| } |
| |
| public static void save() { |
| if (infos != null) { |
| try { |
| infos.save(null); |
| } catch (IOException e) { |
| if (DLTKCore.DEBUG) { |
| // TclPlugin.error(e); |
| } |
| } |
| } |
| synchronized (projectInfos) { |
| for (Map.Entry<String, Resource> entry : projectInfos.entrySet()) { |
| try { |
| entry.getValue().save(null); |
| } catch (IOException e) { |
| String msg = NLS.bind(Messages.TclInterpreterMessages_6, |
| entry.getKey(), e.getMessage()); |
| TclPlugin.error(msg, e); |
| } |
| } |
| } |
| } |
| |
| private static String getXMLContent(List<String> content) { |
| StringBuffer newList = new StringBuffer(); |
| if (content != null) { |
| for (Iterator<String> iterator = content.iterator(); iterator |
| .hasNext();) { |
| String line = iterator.next(); |
| if (line.trim().startsWith("<")) { //$NON-NLS-1$ |
| newList.append(line).append("\n"); //$NON-NLS-1$ |
| } |
| } |
| } |
| return newList.toString(); |
| } |
| |
| private static Document getDocument(String text) { |
| try { |
| DocumentBuilder parser = DocumentBuilderFactory.newInstance() |
| .newDocumentBuilder(); |
| parser.setErrorHandler(new DefaultHandler()); |
| InputSource source = new InputSource(new StringReader(text)); |
| Document document = parser.parse(source); |
| return document; |
| } catch (IOException e) { |
| if (DLTKCore.DEBUG) { |
| e.printStackTrace(); |
| } |
| } catch (ParserConfigurationException e) { |
| if (DLTKCore.DEBUG) { |
| e.printStackTrace(); |
| } |
| } catch (SAXException e) { |
| if (DLTKCore.DEBUG) { |
| e.printStackTrace(); |
| } |
| } |
| return null; |
| } |
| |
| private static synchronized void processContent(List<String> content, |
| boolean markAsFetched, boolean purgePackages, |
| TclInterpreterInfo info) { |
| String text = getXMLContent(content); |
| Document document = getDocument(text); |
| |
| if (document != null) { |
| final Set<String> processedPackages = new HashSet<String>(); |
| Element element = document.getDocumentElement(); |
| NodeList childNodes = element.getChildNodes(); |
| int len = childNodes.getLength(); |
| for (int i = 0; i < len; i++) { |
| Node nde = childNodes.item(i); |
| if (isElementName(nde, "path")) { //$NON-NLS-1$ |
| Element el = (Element) nde; |
| NodeList elChilds = el.getChildNodes(); |
| for (int j = 0; j < elChilds.getLength(); j++) { |
| Node pkgNde = elChilds.item(j); |
| if (isElementName(pkgNde, "package")) { //$NON-NLS-1$ |
| Element pkgElement = (Element) pkgNde; |
| String name = pkgElement.getAttribute("name"); //$NON-NLS-1$ |
| processedPackages.add(name); |
| TclPackageInfo pkg = getCreatePackage(info, name); |
| if (markAsFetched) { |
| pkg.setFetched(markAsFetched); |
| } |
| populatePackage(pkg, pkgNde, info); |
| } |
| } |
| } |
| } |
| if (purgePackages) { |
| for (Iterator<TclPackageInfo> i = info.getPackages().iterator(); i |
| .hasNext();) { |
| TclPackageInfo packageInfo = i.next(); |
| if (!processedPackages.contains(packageInfo.getName())) { |
| i.remove(); |
| } |
| } |
| } |
| } |
| } |
| |
| private static synchronized TclPackageInfo getCreatePackage( |
| TclInterpreterInfo info, String name) { |
| TclPackageInfo packageInfo = null; |
| for (TclPackageInfo pkgInfo : info.getPackages()) { |
| if (pkgInfo.getName().equals(name)) { |
| packageInfo = pkgInfo; |
| break; |
| } |
| } |
| if (packageInfo == null) { |
| packageInfo = TclPackagesFactory.eINSTANCE.createTclPackageInfo(); |
| packageInfo.setFetched(false); |
| packageInfo.setName(name); |
| info.getPackages().add(packageInfo); |
| } |
| return packageInfo; |
| } |
| |
| private static void populatePackage(TclPackageInfo info, Node pkgNde, |
| TclInterpreterInfo interpreterInfo) { |
| Element pkg = (Element) pkgNde; |
| |
| info.setVersion(pkg.getAttribute("version")); //$NON-NLS-1$ |
| NodeList childs = pkg.getChildNodes(); |
| for (int i = 0; i < childs.getLength(); i++) { |
| Node nde = childs.item(i); |
| if (isElementName(nde, "source")) { //$NON-NLS-1$ |
| Element el = (Element) nde; |
| String name = el.getAttribute("name"); //$NON-NLS-1$ |
| info.getSources().add(name); |
| } else if (isElementName(nde, "require")) { //$NON-NLS-1$ |
| Element el = (Element) nde; |
| String name = el.getAttribute("name"); //$NON-NLS-1$ |
| info.getDependencies().add( |
| getCreatePackage(interpreterInfo, name)); |
| } else if (isElementName(nde, "load")) { //$NON-NLS-1$ |
| Element el = (Element) nde; |
| String name = el.getAttribute("name"); //$NON-NLS-1$ |
| info.getLibraries().add(name); |
| } |
| } |
| } |
| |
| private static List<TclPackageInfo> getPackagesForInterpreter( |
| Set<String> packageName, boolean fetchIfRequired, |
| TclInterpreterInfo interpreterInfo, IInterpreterInstall install) { |
| Set<TclPackageInfo> result = new HashSet<TclPackageInfo>(); |
| Set<TclPackageInfo> toFetch = new HashSet<TclPackageInfo>(); |
| synchronized (TclPackagesManager.class) { |
| for (TclPackageInfo tclPackageInfo : interpreterInfo.getPackages()) { |
| if (packageName.contains(tclPackageInfo.getName())) { |
| processPackage(tclPackageInfo, result, toFetch, |
| fetchIfRequired); |
| } |
| } |
| } |
| fetchSources(toFetch, install, interpreterInfo, null); |
| synchronized (TclPackagesManager.class) { |
| for (TclPackageInfo tclPackageInfo : interpreterInfo.getPackages()) { |
| if (packageName.contains(tclPackageInfo.getName())) { |
| processPackage(tclPackageInfo, result, toFetch, |
| fetchIfRequired); |
| } |
| } |
| } |
| return new ArrayList<TclPackageInfo>(result); |
| } |
| |
| private static void processPackage(TclPackageInfo tclPackageInfo, |
| Set<TclPackageInfo> result, Set<TclPackageInfo> toFetch, |
| boolean fetchIfRequired) { |
| if (tclPackageInfo.isFetched() || !fetchIfRequired) { |
| result.add(tclPackageInfo); |
| } else if (fetchIfRequired) { |
| result.add(tclPackageInfo); |
| toFetch.add(tclPackageInfo); |
| } |
| EList<TclPackageInfo> dependencies = tclPackageInfo.getDependencies(); |
| for (TclPackageInfo tclPackageInfo2 : dependencies) { |
| if (!result.contains(tclPackageInfo2)) { |
| processPackage(tclPackageInfo2, result, toFetch, |
| fetchIfRequired); |
| } |
| } |
| } |
| |
| private static void fetchSources(Set<TclPackageInfo> toFetch, |
| IInterpreterInstall install, TclInterpreterInfo interpreterInfo, |
| IProgressMonitor topMonitor) { |
| synchronized (TclPackagesManager.class) { |
| while (sourcesFetchingSet.contains(install)) { |
| // White until it will be removed from fetches list |
| try { |
| TclPackagesManager.class.wait(50); |
| } catch (InterruptedException e) { |
| TclPlugin.error(e); |
| } |
| } |
| // Check for consistency |
| Set<TclPackageInfo> toRemove = new HashSet<TclPackageInfo>(); |
| for (TclPackageInfo tclPackageInfo : toFetch) { |
| if (tclPackageInfo.isFetched()) { |
| toRemove.add(tclPackageInfo); |
| } |
| } |
| toFetch.removeAll(toRemove); |
| if (toFetch.size() == 0) { |
| return; |
| } |
| sourcesFetchingSet.add(install); |
| } |
| |
| /* Progress monitoring */IProgressMonitor monitor = topMonitor; |
| if (monitor == null) { |
| monitor = new ProgressMonitoringJob( |
| Messages.TclInterpreterMessages_RetrievePackageInformationSources |
| + " " + install.getName(), 100); |
| } |
| try { |
| PerformanceNode p = RuntimePerformanceMonitor.begin(); |
| IExecutionEnvironment exeEnv = install.getExecEnvironment(); |
| if (exeEnv == null) { |
| return; |
| } |
| String envName = install.getEnvironment().getName(); |
| /* Progress monitoring */monitor |
| .subTask(Messages.TclInterpreterMessages_DeployingPackageInformationScript); |
| IDeployment deployment = exeEnv.createDeployment(); |
| if (deployment == null) { |
| return; |
| } |
| IFileHandle script = deploy(deployment); |
| |
| if (script == null) { |
| deployment.dispose(); |
| return; |
| } |
| /* Progress monitoring */monitor.worked(10); |
| |
| IFileHandle workingDir = script.getParent(); |
| InterpreterConfig config = ScriptLaunchUtil |
| .createInterpreterConfig(exeEnv, script, workingDir, |
| install.getEnvironmentVariables()); |
| TclLibpathUtils.addTclLibPath(config, |
| install.getLibraryLocations(), install.getEnvironment()); |
| StringBuffer buf = new StringBuffer(); |
| for (TclPackageInfo tclPackageInfo : toFetch) { |
| buf.append(tclPackageInfo.getName()).append(" "); //$NON-NLS-1$ |
| } |
| String names = buf.toString(); |
| ByteArrayInputStream bais = new ByteArrayInputStream(names |
| .getBytes()); |
| /* Progress monitoring */monitor |
| .subTask(Messages.TclInterpreterMessages_DeployingFileWithListOfPackages); |
| IPath packagesPath = null; |
| try { |
| packagesPath = deployment.add(bais, "packages.txt"); //$NON-NLS-1$ |
| } catch (IOException e1) { |
| if (DLTKCore.DEBUG) { |
| e1.printStackTrace(); |
| } |
| deployment.dispose(); |
| return; |
| } |
| /* Progress monitoring */monitor.worked(10); |
| IFileHandle file = deployment.getFile(packagesPath); |
| // For wish |
| config.removeEnvVar("DISPLAY"); //$NON-NLS-1$ |
| String[] arguments = new String[] { "get-srcs", "-fpkgs", //$NON-NLS-1$ //$NON-NLS-2$ |
| file.toOSString() }; |
| |
| config.addScriptArgs(arguments); |
| |
| /* Progress monitoring */monitor |
| .subTask(Messages.TclInterpreterMessages_RunningPackageInfoScript);// MONITORING |
| Process process = null; |
| try { |
| process = ScriptLaunchUtil.runScriptWithInterpreter(exeEnv, |
| install.getInstallLocation().toOSString(), config); |
| } catch (CoreException e) { |
| if (DLTKCore.DEBUG) { |
| e.printStackTrace(); |
| } |
| deployment.dispose(); |
| } |
| if (process == null) { |
| deployment.dispose(); |
| return; |
| } |
| /* Progress monitoring */monitor.worked(10); |
| List<String> output = ProcessOutputCollector.execute(process); |
| /* Progress monitoring */monitor.worked(40); |
| // deployment.dispose(); |
| /* Progress monitoring */monitor |
| .subTask(Messages.TclInterpreterMessages_ProcessingPackagesInfo); |
| processContent(output, true, false, interpreterInfo); |
| /* Progress monitoring */monitor.worked(20); |
| |
| // Mark all toFetch as fetched. |
| for (TclPackageInfo info : toFetch) { |
| info.setFetched(true); |
| } |
| deployment.dispose(); |
| /* Progress monitoring */monitor |
| .subTask(Messages.TclInterpreterMessages_SavePackagesInfo); |
| save(); |
| /* Progress monitoring */monitor.worked(10); |
| p |
| .done( |
| "Tcl", Messages.TclInterpreterMessages_FetchInterpreterSources, 0); //$NON-NLS-1$ |
| } finally { |
| monitor.done(); |
| synchronized (TclPackagesManager.class) { |
| sourcesFetchingSet.remove(install); |
| TclPackagesManager.class.notifyAll(); |
| } |
| } |
| } |
| |
| private static URI getInfoLocation() { |
| final IPath path = TclPlugin.getDefault().getStateLocation().append( |
| "tclPackages_" + PKG_VERSION + ".info"); //$NON-NLS-2$ //$NON-NLS-2$ |
| return URI.createFileURI(path.toOSString()); |
| } |
| |
| private static URI getProjectLocation(String projectName) { |
| final IPath path = TclPlugin.getDefault().getStateLocation().append( |
| "project-" + projectName + ".info"); //$NON-NLS-1$ //$NON-NLS-2$ |
| return URI.createFileURI(path.toOSString()); |
| } |
| |
| private static boolean canLoad(URI location) { |
| if (location.isFile()) { |
| return new File(location.toFileString()).exists(); |
| } else { |
| return true; |
| } |
| } |
| |
| private static class InterpreterInstallChangedListener implements |
| IInterpreterInstallChangedListener { |
| |
| public void defaultInterpreterInstallChanged( |
| IInterpreterInstall previous, IInterpreterInstall current) { |
| // NOP |
| } |
| |
| public void interpreterAdded(IInterpreterInstall Interpreter) { |
| // TODO Auto-generated method stub |
| } |
| |
| public void interpreterChanged(PropertyChangeEvent event) { |
| if (IInterpreterInstallChangedListener.PROPERTY_EXTENSIONS |
| .equals(event.getProperty())) { |
| VariableMap oldVars = locateVariableMap(event.getOldValue()); |
| VariableMap newVars = locateVariableMap(event.getNewValue()); |
| if (oldVars != null || newVars != null) { |
| if (oldVars != null && newVars != null) { |
| if (!EcoreUtil.equals(oldVars, newVars)) { |
| new RebuildProjectsJob((IInterpreterInstall) event |
| .getSource()).schedule(500); |
| } |
| } else { |
| new RebuildProjectsJob((IInterpreterInstall) event |
| .getSource()).schedule(500); |
| } |
| } |
| } |
| } |
| |
| private VariableMap locateVariableMap(Object value) { |
| if (value instanceof List<?>) { |
| for (Object item : (List<?>) value) { |
| if (item instanceof VariableMap) { |
| return (VariableMap) item; |
| } |
| } |
| } |
| return null; |
| } |
| |
| public void interpreterRemoved(IInterpreterInstall Interpreter) { |
| // TODO Auto-generated method stub |
| } |
| |
| } |
| |
| private synchronized static void initialize() { |
| if (installChangedListener == null) { |
| installChangedListener = new InterpreterInstallChangedListener(); |
| ScriptRuntime |
| .addInterpreterInstallChangedListener(installChangedListener); |
| } |
| if (infos == null) { |
| final URI location = getInfoLocation(); |
| infos = new XMIResourceImpl(location); |
| try { |
| if (canLoad(location)) { |
| infos.load(null); |
| } |
| } catch (IOException e) { |
| TclPlugin.error(e); |
| } |
| } |
| } |
| |
| /** |
| * @param name |
| * @return |
| */ |
| private static Resource getProjectInfoResource(String projectName) { |
| synchronized (projectInfos) { |
| final Resource resource = projectInfos.get(projectName); |
| if (resource != null) { |
| return resource; |
| } |
| } |
| final URI location = getProjectLocation(projectName); |
| final Resource resource = new XMIResourceImpl(location); |
| try { |
| if (canLoad(location)) { |
| resource.load(null); |
| } |
| } catch (IOException e) { |
| TclPlugin.error(e); |
| } |
| synchronized (projectInfos) { |
| final Resource r = projectInfos.get(projectName); |
| if (r != null) { |
| return r; |
| } else { |
| projectInfos.put(projectName, resource); |
| return resource; |
| } |
| } |
| } |
| |
| private static List<String> deployExecute(IExecutionEnvironment exeEnv, |
| IInterpreterInstall install, String[] arguments, |
| EnvironmentVariable[] env, ProgressMonitoringJob monitor) { |
| // /* Progress monitoring */String envName = install.getEnvironment() |
| // .getName(); |
| monitor |
| .subTask(Messages.TclInterpreterMessages_DeployingPackageInformationScript); |
| IDeployment deployment = exeEnv.createDeployment(); |
| if (deployment == null) { |
| return null; |
| } |
| IFileHandle script = deploy(deployment); |
| if (script == null) { |
| deployment.dispose(); |
| return null; |
| } |
| /* Progress monitoring */monitor.worked(10); |
| |
| /* Progress monitoring */monitor |
| .subTask(Messages.TclInterpreterMessages_RunningPackageInfoScript); |
| IFileHandle workingDir = script.getParent(); |
| InterpreterConfig config = ScriptLaunchUtil.createInterpreterConfig( |
| exeEnv, script, workingDir, env); |
| TclLibpathUtils.addTclLibPath(config, install.getLibraryLocations(), |
| install.getEnvironment()); |
| // For wish |
| config.removeEnvVar("DISPLAY"); //$NON-NLS-1$ |
| |
| if (arguments != null) { |
| config.addScriptArgs(arguments); |
| } |
| |
| Process process = null; |
| try { |
| process = ScriptLaunchUtil.runScriptWithInterpreter(exeEnv, install |
| .getInstallLocation().toOSString(), config); |
| } catch (CoreException e) { |
| if (DLTKCore.DEBUG) { |
| e.printStackTrace(); |
| } |
| } |
| if (process == null) { |
| deployment.dispose(); |
| return null; |
| } |
| List<String> output = ProcessOutputCollector.execute(process); |
| /* Progress monitoring */monitor.worked(70); |
| deployment.dispose(); |
| return output; |
| } |
| |
| private static IFileHandle deploy(IDeployment deployment) { |
| IFileHandle script; |
| try { |
| IPath path = deployment.add(TclPlugin.getDefault().getBundle(), |
| DLTK_TCL); |
| script = deployment.getFile(path); |
| } catch (IOException e) { |
| if (DLTKCore.DEBUG) { |
| e.printStackTrace(); |
| } |
| return null; |
| } |
| return script; |
| } |
| |
| private static boolean isElementName(Node nde, String name) { |
| if (nde != null) { |
| if (nde.getNodeType() == Node.ELEMENT_NODE) { |
| if (name.equalsIgnoreCase(nde.getNodeName())) { |
| return true; |
| } |
| } |
| } |
| return false; |
| } |
| |
| public static boolean isValidName(String packageName) { |
| return packageName != null && packageName.length() != 0 |
| && packageName.indexOf('$') == -1 |
| && packageName.indexOf('[') == -1 |
| && packageName.indexOf(']') == -1; |
| } |
| |
| /** |
| * Return copy of all modules. |
| * |
| * @param name |
| * @return |
| */ |
| public static synchronized List<TclModuleInfo> getProjectModules(String name) { |
| TclProjectInfo info = getTclProject(name); |
| List<TclModuleInfo> results = new ArrayList<TclModuleInfo>(); |
| |
| EList<TclModuleInfo> modules = info.getModules(); |
| for (TclModuleInfo tclModuleInfo : modules) { |
| TclModuleInfo copy = EcoreUtil.copy(tclModuleInfo); |
| results.add(copy); |
| } |
| return Collections.unmodifiableList(results); |
| } |
| |
| public static synchronized void setProjectModules(String name, |
| List<TclModuleInfo> modules) { |
| TclProjectInfo info = getTclProject(name); |
| info.getModules().clear(); |
| info.getModules().addAll(modules); |
| save(); |
| } |
| |
| public static synchronized void removeInterpreterInfo( |
| IInterpreterInstall install) { |
| initialize(); |
| final TclInterpreterInfo info = getTclInterpreter(install, false); |
| if (info != null) { |
| if (!info.getPackages().isEmpty() || info.isFetched() |
| || info.getFetchedAt() != null) { |
| info.getPackages().clear(); |
| info.setFetched(false); |
| info.setFetchedAt(null); |
| save(); |
| } |
| } |
| } |
| |
| /** |
| * @since 2.0 |
| */ |
| public static synchronized void markInterprterAsNotFetched( |
| IInterpreterInstall install) { |
| initialize(); |
| final TclInterpreterInfo info = getTclInterpreter(install, false); |
| if (info != null) { |
| info.setFetched(false); |
| info.setFetchedAt(null); |
| save(); |
| } |
| } |
| |
| public static Set<String> getPackageInfosAsString( |
| IInterpreterInstall install) { |
| initialize(); |
| Set<String> result = new HashSet<String>(); |
| List<TclPackageInfo> list = getPackageInfos(install); |
| for (TclPackageInfo tclPackageInfo : list) { |
| result.add(tclPackageInfo.getName()); |
| } |
| return result; |
| } |
| |
| private static EMap<String, VariableValue> convertVariablesToEMap( |
| Map<String, String> variables) { |
| final EMap<String, VariableValue> result = new BasicEMap<String, VariableValue>(); |
| for (Map.Entry<String, String> entry : variables.entrySet()) { |
| final VariableValue value = TclPackagesFactory.eINSTANCE |
| .createVariableValue(); |
| value.setValue(entry.getValue()); |
| result.put(entry.getKey(), value); |
| } |
| return result; |
| } |
| |
| private static Map<String, String> convertVariablesToMap( |
| EMap<String, VariableValue> variables) { |
| final Map<String, String> result = new HashMap<String, String>(); |
| for (Map.Entry<String, VariableValue> entry : variables.entrySet()) { |
| result.put(entry.getKey(), entry.getValue().getValue()); |
| } |
| return result; |
| } |
| |
| /** |
| * @since 2.0 |
| */ |
| public static Map<String, String> getVariables(IInterpreterInstall install) { |
| return convertVariablesToMap(getVariablesEMap(install)); |
| } |
| |
| /** |
| * @since 2.0 |
| */ |
| public static EMap<String, VariableValue> getVariablesEMap( |
| IInterpreterInstall install) { |
| final EObject variables = install |
| .findExtension(TclPackagesPackage.Literals.VARIABLE_MAP); |
| if (variables != null) { |
| return ECollections.unmodifiableEMap(((VariableMap) variables) |
| .getVariables()); |
| } else { |
| return ECollections.emptyEMap(); |
| } |
| } |
| |
| /** |
| * @since 2.0 |
| */ |
| public static void setVariables(IInterpreterInstall install, |
| Map<String, String> variables) { |
| setVariables(install, convertVariablesToEMap(variables)); |
| } |
| |
| /** |
| * @since 2.0 |
| */ |
| public static void setVariables(IInterpreterInstall install, |
| EMap<String, VariableValue> variables) { |
| if (variables != null && !variables.isEmpty()) { |
| final VariableMap variableMap = TclPackagesFactory.eINSTANCE |
| .createVariableMap(); |
| variableMap.getVariables().putAll(variables); |
| install.replaceExtension(TclPackagesPackage.Literals.VARIABLE_MAP, |
| variableMap); |
| } else { |
| install.replaceExtension(TclPackagesPackage.Literals.VARIABLE_MAP, |
| null); |
| } |
| } |
| |
| /** |
| * @since 2.0 |
| */ |
| public static Map<String, String> getVariables(String projectName) { |
| return convertVariablesToMap(getVariablesEMap(projectName)); |
| } |
| |
| /** |
| * @since 2.0 |
| */ |
| public static synchronized EMap<String, VariableValue> getVariablesEMap( |
| String projectName) { |
| TclProjectInfo projectInfo = getTclProject(projectName); |
| return ECollections.unmodifiableEMap(projectInfo.getVariables()); |
| } |
| |
| /** |
| * @since 2.0 |
| */ |
| public static void setVariables(String projectName, |
| Map<String, String> variables) { |
| setVariables(projectName, convertVariablesToEMap(variables)); |
| } |
| |
| /** |
| * @since 2.0 |
| */ |
| public static synchronized void setVariables(String projectName, |
| EMap<String, VariableValue> variables) { |
| TclProjectInfo projectInfo = getTclProject(projectName); |
| projectInfo.getVariables().clear(); |
| projectInfo.getVariables().putAll(variables); |
| save(); |
| } |
| |
| /** |
| * @since 2.0 |
| */ |
| public static void fillPackagesFromContent(List<String> content, |
| TclInterpreterInfo info) { |
| String text = getXMLContent(content); |
| Document document = getDocument(text); |
| Set<TclPackageInfo> packages = new HashSet<TclPackageInfo>(); |
| |
| if (document != null) { |
| Element element = document.getDocumentElement(); |
| NodeList childNodes = element.getChildNodes(); |
| int len = childNodes.getLength(); |
| for (int i = 0; i < len; i++) { |
| Node nde = childNodes.item(i); |
| if (isElementName(nde, "path")) { //$NON-NLS-1$ |
| Element el = (Element) nde; |
| NodeList elChilds = el.getChildNodes(); |
| for (int j = 0; j < elChilds.getLength(); j++) { |
| Node pkgNde = elChilds.item(j); |
| if (isElementName(pkgNde, "package")) { //$NON-NLS-1$ |
| Element pkgElement = (Element) pkgNde; |
| String name = pkgElement.getAttribute("name"); //$NON-NLS-1$ |
| |
| TclPackageInfo pkg = getCreatePackage(info, name); |
| populatePackage(pkg, pkgNde, info); |
| packages.add(pkg); |
| } |
| } |
| } |
| } |
| } |
| } |
| |
| /** |
| * |
| * Fetch only one package information to info |
| * |
| * @since 2.0 |
| */ |
| public static TclPackageInfo getPackageInfo(InterpreterStandin install, |
| String name, boolean fetch, TclInterpreterInfo info, |
| IProgressMonitor monitor) { |
| EList<TclPackageInfo> packages = info.getPackages(); |
| Set<TclPackageInfo> toFetch = new HashSet<TclPackageInfo>(); |
| TclPackageInfo result = null; |
| |
| synchronized (TclPackagesManager.class) { |
| for (TclPackageInfo tclPackageInfo : packages) { |
| if (name.equals(tclPackageInfo.getName())) { |
| if (tclPackageInfo.isFetched()) { |
| return tclPackageInfo; |
| } else { |
| toFetch.add(tclPackageInfo); |
| fetchSources(toFetch, install, info, monitor); |
| result = tclPackageInfo; |
| break; |
| } |
| } |
| } |
| } |
| return result; |
| } |
| } |
