| /* | |
| * Licensed to the Apache Software Foundation (ASF) under one | |
| * or more contributor license agreements. See the NOTICE file | |
| * distributed with this work for additional information | |
| * regarding copyright ownership. The ASF licenses this file | |
| * to you under the Apache License, Version 2.0 (the | |
| * "License"); you may not use this file except in compliance | |
| * with the License. You may obtain a copy of the License at | |
| * | |
| * http://www.apache.org/licenses/LICENSE-2.0 | |
| * | |
| * Unless required by applicable law or agreed to in writing, | |
| * software distributed under the License is distributed on an | |
| * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY | |
| * KIND, either express or implied. See the License for the | |
| * specific language governing permissions and limitations | |
| * under the License. | |
| */ | |
| package org.apache.karaf.eik.felix; | |
| import org.apache.karaf.eik.felix.internal.BundleEntry; | |
| import org.apache.karaf.eik.felix.internal.FelixLaunchHelper; | |
| import java.io.File; | |
| import java.io.FileOutputStream; | |
| import java.io.IOException; | |
| import java.io.OutputStream; | |
| import java.net.MalformedURLException; | |
| import java.net.URL; | |
| import java.util.ArrayList; | |
| import java.util.Collection; | |
| import java.util.HashMap; | |
| import java.util.Iterator; | |
| import java.util.List; | |
| import java.util.Map; | |
| import java.util.Properties; | |
| import java.util.Set; | |
| import java.util.StringTokenizer; | |
| import org.eclipse.core.resources.IProject; | |
| import org.eclipse.core.resources.IResource; | |
| import org.eclipse.core.runtime.CoreException; | |
| import org.eclipse.core.runtime.FileLocator; | |
| import org.eclipse.core.runtime.IPath; | |
| import org.eclipse.core.runtime.IProgressMonitor; | |
| import org.eclipse.core.runtime.Path; | |
| import org.eclipse.core.runtime.Platform; | |
| import org.eclipse.core.variables.IStringVariableManager; | |
| import org.eclipse.core.variables.VariablesPlugin; | |
| import org.eclipse.debug.core.ILaunch; | |
| import org.eclipse.debug.core.ILaunchConfiguration; | |
| import org.eclipse.jdt.core.IClasspathEntry; | |
| import org.eclipse.jdt.core.IJavaProject; | |
| import org.eclipse.jdt.core.IPackageFragmentRoot; | |
| import org.eclipse.jdt.core.JavaCore; | |
| import org.eclipse.jdt.launching.ExecutionArguments; | |
| import org.eclipse.jdt.launching.IJavaLaunchConfigurationConstants; | |
| import org.eclipse.pde.core.plugin.IPluginModelBase; | |
| import org.eclipse.pde.core.plugin.PluginRegistry; | |
| import org.eclipse.pde.ui.launcher.AbstractPDELaunchConfiguration; | |
| import org.eclipse.pde.ui.launcher.IPDELauncherConstants; | |
| import org.osgi.framework.Bundle; | |
| public class FelixLaunchConfiguration extends AbstractPDELaunchConfiguration { | |
| public static final String FELIX_FRAMEWORK_LAUNCHER = "org.apache.felix.main"; | |
| public static final String FELIX_FRAMEWORK = "org.apache.felix.framework"; | |
| public static final String FELIX_SYSTEM_PROPERTIES_KEY = "felix.system.properties"; | |
| public static final String FELIX_CONFIG_PROPERTIES_KEY = "felix.config.properties"; | |
| public static final String FELIX_AUTO_START_PREFIX = "felix.auto.start."; | |
| public static final String FELIX_AUTO_INSTALL_PREFIX = "felix.auto.install."; | |
| public static final String FELIX_CONFIG_PROPERTIES_FILE = "config.properties"; | |
| public static final String FELIX_SYSTEM_PROPERTIES_FILE = "system.properties"; | |
| public static final int DEFAULT_START_LEVEL = 4; | |
| public static final boolean DEFAULT_AUTOSTART = true; | |
| /** | |
| * Implementation of join using a {@link StringBuffer} | |
| * | |
| * @param items | |
| * the {@link Collection} of items that will be joined together | |
| * @param glue | |
| * the string to act as glue in the concatenation | |
| * @return the concatenation of the specified items | |
| */ | |
| public static String join(Collection<String> items, String glue) { | |
| final StringBuffer buffer = new StringBuffer(); | |
| for (String s : items) { | |
| if (buffer.length() > 0) { | |
| buffer.append(glue); | |
| } | |
| buffer.append(s); | |
| } | |
| return buffer.toString(); | |
| } | |
| /** | |
| * Gets the path to the specified bundle in the following manner:<br> | |
| * <br> | |
| * <ol> | |
| * <li>If the bundle is found in the Plug-in Registry and is not a workspace | |
| * resource, return the path to the bundle</li> | |
| * <li>If the bundle is in the Plug-in Registry but is a workspace resource, | |
| * return the path to the path to the output location that contains the | |
| * package specified ({@code project/output folder})</li> | |
| * <li>If the bundle is not found in the Plug-in Registry then look for it | |
| * in the OSGi platform</li> | |
| * </ol> | |
| * | |
| * @param bundleName | |
| * the symbolic name of the bundle | |
| * @param packageName | |
| * the name of the package used to locate the output folder | |
| * @return a fully qualified path to the requested bundle or null if it does | |
| * not exist | |
| * @throws CoreException | |
| */ | |
| private static String getBundlePath(String bundleName, String packageName) throws CoreException { | |
| final IPluginModelBase model = PluginRegistry.findModel(bundleName); | |
| if (model != null) { | |
| final IResource resource = model.getUnderlyingResource(); | |
| if (!isWorkspaceModel(model)) { | |
| return model.getInstallLocation(); | |
| } | |
| final IProject project = resource.getProject(); | |
| if (project.hasNature(JavaCore.NATURE_ID)) { | |
| final IJavaProject jProject = JavaCore.create(project); | |
| final IClasspathEntry[] entries = jProject.getRawClasspath(); | |
| for (int i = 0; i < entries.length; i++) { | |
| final int kind = entries[i].getEntryKind(); | |
| if (kind == IClasspathEntry.CPE_SOURCE || kind == IClasspathEntry.CPE_LIBRARY) { | |
| final IPackageFragmentRoot[] roots = jProject.findPackageFragmentRoots(entries[i]); | |
| for (int j = 0; j < roots.length; j++) { | |
| if (roots[j].getPackageFragment(packageName).exists()) { | |
| // if source folder, find the output folder | |
| if (kind == IClasspathEntry.CPE_SOURCE) { | |
| IPath path = entries[i].getOutputLocation(); | |
| if (path == null) { | |
| path = jProject.getOutputLocation(); | |
| } | |
| path = path.removeFirstSegments(1); | |
| return project.getLocation().append(path).toOSString(); | |
| } | |
| // else if is a library jar, then get the | |
| // location of the jar itself | |
| final IResource jar = roots[j].getResource(); | |
| if (jar != null) { | |
| return jar.getLocation().toOSString(); | |
| } | |
| } | |
| } | |
| } | |
| } | |
| } | |
| } | |
| final Bundle bundle = Platform.getBundle(bundleName); | |
| if (bundle != null) { | |
| try { | |
| URL url = FileLocator.resolve(bundle.getEntry("/")); //$NON-NLS-1$ | |
| url = FileLocator.toFileURL(url); | |
| String path = url.getFile(); | |
| if (path.startsWith("file:")) { //$NON-NLS-1$ | |
| path = path.substring(5); | |
| } | |
| path = new File(path).getAbsolutePath(); | |
| if (path.endsWith("!")) { //$NON-NLS-1$ | |
| path = path.substring(0, path.length() - 1); | |
| } | |
| return path; | |
| } catch (IOException e) { | |
| } | |
| } | |
| return null; | |
| } | |
| /** | |
| * Uses the Eclipse Variables plugin to perform string substitution on the | |
| * input string | |
| * | |
| * @param text | |
| * the input string that potentially contains variables that need | |
| * to be resolved | |
| * @return the fully interpolated string | |
| * @throws CoreException | |
| */ | |
| private static String getSubstitutedString(String text) throws CoreException { | |
| if (text == null) { | |
| return ""; //$NON-NLS-1$ | |
| } | |
| final IStringVariableManager mgr = VariablesPlugin.getDefault().getStringVariableManager(); | |
| return mgr.performStringSubstitution(text); | |
| } | |
| /** | |
| * Determines if the {@link IPluginModelBase} is a workspace resource | |
| * | |
| * @param model | |
| * the {@code IPluginModelBase} to test | |
| * @return true if it is a workspace resource, false otherwise | |
| */ | |
| private static boolean isWorkspaceModel(IPluginModelBase model) { | |
| return (model.getUnderlyingResource() != null); | |
| } | |
| /** | |
| * Helper method to write a properties file to the specified filename | |
| * | |
| * @param filename | |
| * the fully qualfied filename | |
| * @param props | |
| * the {@link Properties} to be stored | |
| * @throws CoreException | |
| */ | |
| private static void writeProperties(String filename, Properties props) throws CoreException { | |
| try { | |
| final OutputStream out = new FileOutputStream(new File(filename)); | |
| props.store(out, FelixLaunchConfiguration.class.getName()); | |
| out.close(); | |
| } catch (IOException e) { | |
| } | |
| } | |
| // used to generate the dev classpath entries | |
| // key is bundle ID, value is a model | |
| protected Map<String, IPluginModelBase> fAllBundles; | |
| // key is a model, value is startLevel:autoStart | |
| private Map<IPluginModelBase, String> fModels; | |
| /* | |
| * Apache Felix requires that the launcher and the Felix Framework be on the | |
| * initial classpath. | |
| * | |
| * @see | |
| * org.eclipse.pde.ui.launcher.AbstractPDELaunchConfiguration#getClasspath | |
| * (org.eclipse.debug.core.ILaunchConfiguration) | |
| */ | |
| @Override | |
| public String[] getClasspath(ILaunchConfiguration configuration) throws CoreException { | |
| final String felixLauncherPath = getBundlePath(FELIX_FRAMEWORK_LAUNCHER, FELIX_FRAMEWORK_LAUNCHER); | |
| if (felixLauncherPath == null) { | |
| } | |
| final String felixFrameworkPath = getBundlePath(FELIX_FRAMEWORK, FELIX_FRAMEWORK); | |
| if (felixFrameworkPath == null) { | |
| } | |
| final List<String> entries = new ArrayList<String>(); | |
| entries.add(felixLauncherPath); | |
| entries.add(felixFrameworkPath); | |
| /* | |
| * Add any boostrap entries provided by the user | |
| */ | |
| final String bootstrap = configuration.getAttribute(IPDELauncherConstants.BOOTSTRAP_ENTRIES, ""); //$NON-NLS-1$ | |
| final StringTokenizer tok = new StringTokenizer(getSubstitutedString(bootstrap), ","); //$NON-NLS-1$ | |
| while (tok.hasMoreTokens()) { | |
| entries.add(tok.nextToken().trim()); | |
| } | |
| return entries.toArray(new String[entries.size()]); | |
| } | |
| @Override | |
| public String getMainClass() { | |
| return "org.apache.felix.main.Main"; //$NON-NLS-1$ | |
| } | |
| /* | |
| * Gets any additional program arguments from the user and writes all Felix | |
| * configuration files | |
| * | |
| * @seeorg.eclipse.pde.ui.launcher.AbstractPDELaunchConfiguration# | |
| * getProgramArguments(org.eclipse.debug.core.ILaunchConfiguration) | |
| */ | |
| @Override | |
| public String[] getProgramArguments(ILaunchConfiguration configuration) throws CoreException { | |
| String args = configuration.getAttribute(IJavaLaunchConfigurationConstants.ATTR_PROGRAM_ARGUMENTS, (String) null); | |
| args = args == null ? "" : getSubstitutedString(args); //$NON-NLS-1$ | |
| writeConfigProperties(configuration); | |
| writeSystemProperties(configuration); | |
| writeStartupProperties(configuration); | |
| return new ExecutionArguments("", args).getProgramArgumentsArray(); //$NON-NLS-1$ | |
| } | |
| /* | |
| * Adds the base VM arguments and root system properties used to load the | |
| * Felix configuration files. | |
| * | |
| * @see | |
| * org.eclipse.pde.ui.launcher.AbstractPDELaunchConfiguration#getVMArguments | |
| * (org.eclipse.debug.core.ILaunchConfiguration) | |
| */ | |
| @Override | |
| public String[] getVMArguments(ILaunchConfiguration configuration) throws CoreException { | |
| String args = configuration.getAttribute(IJavaLaunchConfigurationConstants.ATTR_VM_ARGUMENTS, (String) null); | |
| args = args == null ? "" : getSubstitutedString(args); //$NON-NLS-1$ | |
| final IPath configProperties = new Path(new File(getConfigDir(configuration), FELIX_CONFIG_PROPERTIES_FILE).getAbsolutePath()); | |
| final IPath systemProperties = new Path(new File(getConfigDir(configuration), FELIX_SYSTEM_PROPERTIES_FILE).getAbsolutePath()); | |
| final String[] vmArgs = new ExecutionArguments("", args).getVMArgumentsArray(); //$NON-NLS-1$ | |
| // arraycopy works for JDK 5 & 6 | |
| final String[] newVmArgs = new String[vmArgs.length + 2]; | |
| System.arraycopy(vmArgs, 0, newVmArgs, 0, vmArgs.length); | |
| try { | |
| // TODO: Properly merge arguments in | |
| newVmArgs[vmArgs.length] = "-D" + FELIX_CONFIG_PROPERTIES_KEY + "=" + configProperties.toFile().toURI().toURL(); | |
| newVmArgs[vmArgs.length + 1] = "-D" + FELIX_SYSTEM_PROPERTIES_KEY + "=" + systemProperties.toFile().toURI().toURL(); | |
| } catch (MalformedURLException e) { | |
| } | |
| return newVmArgs; | |
| } | |
| /** | |
| * Writes out the configuration properties including bundle start and | |
| * install values | |
| * | |
| * @param configuration | |
| * the launch configuration | |
| * @throws CoreException | |
| */ | |
| private void writeConfigProperties(ILaunchConfiguration configuration) throws CoreException { | |
| final File f = new File(getConfigDir(configuration), FELIX_CONFIG_PROPERTIES_FILE); | |
| final boolean defaultAutostart = configuration.getAttribute(IPDELauncherConstants.DEFAULT_AUTO_START, DEFAULT_AUTOSTART); | |
| final int defaultStart = configuration.getAttribute(IPDELauncherConstants.DEFAULT_START_LEVEL, DEFAULT_START_LEVEL); | |
| final Properties properties = new Properties(); | |
| properties.put("osgi.bundles.defaultStartLevel", Integer.toString(defaultStart)); //$NON-NLS-1$ | |
| properties.put("org.osgi.framework.startlevel.beginning", Integer.toString(defaultStart)); //$NON-NLS-1$ | |
| final Map<String, List<String>> startEntries = new HashMap<String, List<String>>(); | |
| final Map<String, List<String>> installEntries = new HashMap<String, List<String>>(); | |
| for (IPluginModelBase model : fModels.keySet()) { | |
| final String startString = fModels.get(model); | |
| final int colonPos = startString.indexOf(":"); | |
| Integer startLevel; | |
| String s = startString.substring(0, colonPos); | |
| if ("default".equals(s)) { | |
| startLevel = defaultStart; | |
| } else { | |
| startLevel = new Integer(s); | |
| } | |
| boolean autostart; | |
| s = startString.substring(colonPos + 1); | |
| if ("default".equals(s)) { | |
| autostart = defaultAutostart; | |
| } else { | |
| autostart = new Boolean(s); | |
| } | |
| List<String> entries; | |
| if (autostart) { | |
| entries = startEntries.get(FELIX_AUTO_START_PREFIX + startLevel.toString()); | |
| if (entries == null) { | |
| entries = new ArrayList<String>(); | |
| startEntries.put(FELIX_AUTO_START_PREFIX + startLevel.toString(), entries); | |
| } | |
| } else { | |
| entries = startEntries.get(FELIX_AUTO_INSTALL_PREFIX + startLevel.toString()); | |
| if (entries == null) { | |
| entries = new ArrayList<String>(); | |
| installEntries.put(FELIX_AUTO_INSTALL_PREFIX + startLevel.toString(), entries); | |
| } | |
| } | |
| try { | |
| final File bundle = new File(model.getBundleDescription().getLocation()); | |
| entries.add(bundle.toURI().toURL().toString()); | |
| } catch (MalformedURLException e) { | |
| } | |
| } | |
| for (Map.Entry<String, List<String>> e : startEntries.entrySet()) { | |
| properties.put(e.getKey(), join(e.getValue(), " ")); | |
| } | |
| for (Map.Entry<String, List<String>> e : installEntries.entrySet()) { | |
| properties.put(e.getKey(), join(e.getValue(), " ")); | |
| } | |
| writeProperties(f.getAbsolutePath(), properties); | |
| } | |
| private void writeStartupProperties(ILaunchConfiguration configuration) throws CoreException { | |
| final File f = new File(getConfigDir(configuration), "startup.properties"); //$NON-NLS-1$ | |
| final Properties properties = new Properties(); | |
| writeProperties(f.getAbsolutePath(), properties); | |
| } | |
| private void writeSystemProperties(ILaunchConfiguration configuration) throws CoreException { | |
| final File f = new File(getConfigDir(configuration), FELIX_SYSTEM_PROPERTIES_FILE); | |
| final Properties properties = new Properties(); | |
| writeProperties(f.getAbsolutePath(), properties); | |
| } | |
| /* | |
| * Sets up the initial map of bundles. | |
| * | |
| * @see | |
| * org.eclipse.pde.ui.launcher.AbstractPDELaunchConfiguration#preLaunchCheck | |
| * (org.eclipse.debug.core.ILaunchConfiguration, | |
| * org.eclipse.debug.core.ILaunch, | |
| * org.eclipse.core.runtime.IProgressMonitor) | |
| */ | |
| @Override | |
| protected void preLaunchCheck(ILaunchConfiguration configuration, ILaunch launch, IProgressMonitor monitor) throws CoreException { | |
| final String workspace = configuration.getAttribute(IPDELauncherConstants.WORKSPACE_BUNDLES, ""); //$NON-NLS-1$ | |
| final String target = configuration.getAttribute(IPDELauncherConstants.TARGET_BUNDLES, ""); //$NON-NLS-1$ | |
| final List<BundleEntry> workspaceBundles = FelixLaunchHelper.getBundles(workspace); | |
| final List<BundleEntry> targetBundles = FelixLaunchHelper.getBundles(target); | |
| fModels = new HashMap<IPluginModelBase, String>(); | |
| for(BundleEntry e : workspaceBundles) { | |
| final IPluginModelBase model = FelixLaunchHelper.resolveWorkspaceBundleEntry(e); | |
| if(model == null) { | |
| continue; | |
| } | |
| fModels.put(model, e.getAutostart() + ":" + e.getStartLevel()); //$NON-NLS-1$ | |
| } | |
| if (configuration.getAttribute(IPDELauncherConstants.AUTOMATIC_ADD, true)) { | |
| automaticallyAddWorkspaceBundles(configuration); | |
| } | |
| for(BundleEntry e : targetBundles) { | |
| final IPluginModelBase model = FelixLaunchHelper.resolveTargetBundleEntry(e); | |
| if(model == null) { | |
| continue; | |
| } | |
| fModels.put(model, e.getAutostart() + ":" + e.getStartLevel()); //$NON-NLS-1$ | |
| } | |
| fAllBundles = new HashMap<String, IPluginModelBase>(fModels.size()); | |
| final Iterator<IPluginModelBase> iter = fModels.keySet().iterator(); | |
| while (iter.hasNext()) { | |
| final IPluginModelBase model = iter.next(); | |
| fAllBundles.put(model.getPluginBase().getId(), model); | |
| } | |
| super.preLaunchCheck(configuration, launch, monitor); | |
| } | |
| private void automaticallyAddWorkspaceBundles(ILaunchConfiguration configuration) throws CoreException { | |
| final Set<IPluginModelBase> deselectedPlugins = FelixLaunchHelper.getDeselectedPluginSet(configuration); | |
| final IPluginModelBase[] models = PluginRegistry.getWorkspaceModels(); | |
| for (int i = 0; i < models.length; i++) { | |
| final String id = models[i].getPluginBase().getId(); | |
| if (id == null) { | |
| continue; | |
| } | |
| if (!deselectedPlugins.contains(models[i])) { | |
| if (!fModels.containsKey(models[i])) { | |
| fModels.put(models[i], "default:default"); //$NON-NLS-1$ | |
| } | |
| } | |
| } | |
| } | |
| } |