/*
* 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.ui.workbench.internal;
import org.apache.karaf.eik.core.IKarafConstants;
import org.apache.karaf.eik.core.KarafCorePluginUtils;
import org.apache.karaf.eik.core.KarafPlatformModel;
import org.apache.karaf.eik.core.KarafWorkingPlatformModel;
import org.apache.karaf.eik.core.PropertyUtils;
import org.apache.karaf.eik.core.configuration.FeaturesSection;
import org.apache.karaf.eik.core.configuration.ManagementSection;
import org.apache.karaf.eik.core.equinox.BundleEntry;
import org.apache.karaf.eik.core.model.GenericKarafPlatformModel;
import org.apache.karaf.eik.core.shell.KarafSshConnectionUrl;
import org.apache.karaf.eik.core.shell.KarafSshShellConnection;
import org.apache.karaf.eik.ui.IKarafProject;
import org.apache.karaf.eik.ui.KarafLaunchConfigurationConstants;
import org.apache.karaf.eik.ui.KarafUIPluginActivator;
import org.apache.karaf.eik.ui.console.KarafRemoteConsole;
import org.apache.karaf.eik.ui.workbench.KarafWorkbenchService;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Properties;
import org.eclipse.core.resources.IFile;
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.Status;
import org.eclipse.debug.core.DebugPlugin;
import org.eclipse.debug.core.ILaunch;
import org.eclipse.debug.core.ILaunchConfiguration;
import org.eclipse.debug.core.ILaunchConfigurationWorkingCopy;
import org.eclipse.debug.core.ILaunchListener;
import org.eclipse.debug.core.model.IProcess;
import org.eclipse.debug.ui.IDebugUIConstants;
import org.eclipse.debug.ui.console.ConsoleColorProvider;
import org.eclipse.jdt.launching.IJavaLaunchConfigurationConstants;
import org.eclipse.jdt.launching.SocketUtil;
import org.eclipse.jface.text.IDocument;
import org.eclipse.ui.console.ConsolePlugin;
import org.eclipse.ui.console.IConsole;
import org.eclipse.ui.console.IConsoleManager;
public class GenericKarafWorkbenchService implements KarafWorkbenchService {
private final class KarafConsoleLaunchListener implements ILaunchListener {
/**
* Returns the console for the given {@link IProcess}, or {@code null}
* if none.
*
* @param process
* the {@code IProcess} whose console is to be found
* @return the console for the given process, or {@code null} if none
*/
public IConsole findConsole(final IProcess process) {
final IConsoleManager manager = ConsolePlugin.getDefault().getConsoleManager();
for (final IConsole console : manager.getConsoles()) {
if (console instanceof KarafRemoteConsole) {
final KarafRemoteConsole karafConsole = (KarafRemoteConsole) console;
if (karafConsole.getProcess().equals(process)) {
return karafConsole;
}
}
}
return null;
}
/**
* Returns the {@link IDocument} for the {@link IProcess}, or
* {@code null} if none is available.
*
* @param process
* the {@code IProcess} whose document is to be retrieved
* @return the {@code IDocument} for the specified {@code IProcess} or
* {@code null} if one could not be found
*/
public IDocument getConsoleDocument(final IProcess process) {
final KarafRemoteConsole console = (KarafRemoteConsole) findConsole(process);
return console != null ? console.getDocument() : null;
}
@Override
public void launchAdded(final ILaunch launch) {
launchChanged(launch);
}
@Override
public void launchChanged(final ILaunch launch) {
if (!isKarafLaunch(launch)) {
return;
}
for (final IProcess process : launch.getProcesses()) {
if (getConsoleDocument(process) != null) {
continue;
}
if (process.getStreamsProxy() == null) {
continue;
}
final String encoding = launch.getAttribute(DebugPlugin.ATTR_CONSOLE_ENCODING);
final KarafPlatformModel karafPlatform =
(KarafPlatformModel) launch.getLaunchConfiguration().getAdapter(KarafPlatformModel.class);
final KarafSshConnectionUrl sshConnectionUrl =
(KarafSshConnectionUrl) karafPlatform.getAdapter(KarafSshConnectionUrl.class);
final KarafSshShellConnection.Credentials credentials;
try {
final String username =
launch.getLaunchConfiguration().getAttribute(KarafLaunchConfigurationConstants.KARAF_REMOTE_CONSOLE_USERNAME, "karaf");
final String password =
launch.getLaunchConfiguration().getAttribute(KarafLaunchConfigurationConstants.KARAF_REMOTE_CONSOLE_PASSWORD, "karaf");
credentials = new KarafSshShellConnection.Credentials(username, password);
} catch (final CoreException e) {
throw new AssertionError(e);
}
final KarafRemoteConsole remoteConsole = new KarafRemoteConsole(
process,
sshConnectionUrl,
credentials,
new ConsoleColorProvider(),
launch.getLaunchConfiguration().getName(),
encoding);
remoteConsole.setAttribute(IDebugUIConstants.ATTR_CONSOLE_PROCESS, process);
ConsolePlugin.getDefault().getConsoleManager().addConsoles(new IConsole[] { remoteConsole });
}
}
@Override
public void launchRemoved(final ILaunch launch) {
if (!isKarafLaunch(launch)) {
return;
}
for (final IProcess process : launch.getProcesses()) {
final IConsole console = findConsole(process);
if (console != null) {
final IConsoleManager manager = ConsolePlugin.getDefault().getConsoleManager();
manager.removeConsoles(new IConsole[] { console });
}
}
}
/**
* Determines whether or not the {@link ILaunch} is from an EIK launch
*
* @param launch
* the {@code ILaunch} to evaluate
* @return true if the {@code ILaunch} is an EIK launch
*/
private boolean isKarafLaunch(final ILaunch launch) {
try {
final ILaunchConfiguration configuration = launch.getLaunchConfiguration();
if (!configuration.getAttributes().containsKey(KarafLaunchConfigurationConstants.KARAF_LAUNCH_START_REMOTE_CONSOLE)) {
return false;
}
return true;
} catch (final CoreException e) {
return false;
}
}
}
public GenericKarafWorkbenchService() {
DebugPlugin.getDefault().getLaunchManager().addLaunchListener(new KarafConsoleLaunchListener());
}
@Override
public List<BundleEntry> getAdditionalBundles(final KarafWorkingPlatformModel platformModel, final ILaunchConfiguration configuration) {
if (!platformModel.getParentKarafModel().getClass().equals(GenericKarafPlatformModel.class)) {
return Collections.emptyList();
}
final String[] bundles = {
"org.apache.karaf.eik.app",
"org.eclipse.core.contenttype",
"org.eclipse.core.jobs",
"org.eclipse.core.runtime",
"org.eclipse.core.runtime.compatibility.auth",
"org.eclipse.equinox.app",
"org.eclipse.equinox.common",
"org.eclipse.equinox.registry",
"org.eclipse.equinox.preferences",
"org.eclipse.osgi.util"
};
final List<BundleEntry> bundleEntries = new ArrayList<BundleEntry>();
for (final String b : bundles) {
// If the bundle is already present in the platform, don't add it
if (platformModel.getState().getBundle(b, null) != null) {
continue;
}
final String bundleLocation =
KarafCorePluginUtils.getBundleLocation(b);
final BundleEntry entry =
new BundleEntry.Builder(bundleLocation).startLevel("1").autostart("start").build(); //$NON-NLS-1$ $NON-NLS-2$
bundleEntries.add(entry);
}
return bundleEntries;
}
@Override
public Map<String, String> getAdditionalEquinoxConfiguration(final KarafWorkingPlatformModel platformModel, final ILaunchConfiguration configuration) {
if (!platformModel.getParentKarafModel().getClass().equals(GenericKarafPlatformModel.class)) {
return Collections.emptyMap();
}
final Map<String, String> equinoxProperties = new HashMap<String, String>();
final Properties currentConfig;
try {
currentConfig =
KarafCorePluginUtils.loadProperties(
platformModel.getParentKarafModel().getConfigurationDirectory().toFile(),
IKarafConstants.KARAF_DEFAULT_CONFIG_PROPERTIES_FILE,
true);
final Properties systemProperties = createLaunchSystemProperties(platformModel, configuration);
currentConfig.putAll(systemProperties);
PropertyUtils.interpolateVariables(currentConfig, currentConfig);
for (final Map.Entry<Object, Object> e : currentConfig.entrySet()) {
equinoxProperties.put((String)e.getKey(), (String)e.getValue());
}
} catch(final CoreException e) {
KarafUIPluginActivator.getLogger().error("Unable to load configuration file: " + platformModel.getParentKarafModel().getConfigurationDirectory(), e);
}
addEclipseObrFile(platformModel, equinoxProperties);
equinoxProperties.put(
IKarafConstants.KARAF_BASE_PROP,
platformModel.getParentKarafModel().getRootDirectory().toOSString());
equinoxProperties.put(
IKarafConstants.KARAF_HOME_PROP,
platformModel.getParentKarafModel().getRootDirectory().toOSString());
/*
* Adds the $TARGET_HOME/<system plugins> directory to the default
* bundle.locations search space
*/
equinoxProperties.put(
IKarafConstants.KARAF_BUNDLE_LOCATIONS_PROP,
platformModel.getPluginRootDirectory().toOSString());
return equinoxProperties;
}
@Override
public List<String> getVMArguments(
final KarafWorkingPlatformModel platformModel,
final ILaunchConfiguration configuration)
throws CoreException
{
if (!platformModel.getParentKarafModel().getClass().equals(GenericKarafPlatformModel.class)) {
return Collections.emptyList();
}
final Properties systemProperties = createLaunchSystemProperties(platformModel, configuration);
final List<String> arguments = new ArrayList<String>();
for (final Map.Entry<Object, Object> e : systemProperties.entrySet()) {
arguments.add(
KarafCorePluginUtils.constructSystemProperty(
(String) e.getKey(),
(String) e.getValue()));
}
return arguments;
}
@Override
public void initialize(final KarafWorkingPlatformModel platformModel, final ILaunchConfigurationWorkingCopy configuration) {
if (!platformModel.getParentKarafModel().getClass().equals(GenericKarafPlatformModel.class)) {
return;
}
configuration.setAttribute(
IJavaLaunchConfigurationConstants.ATTR_WORKING_DIRECTORY,
platformModel.getParentKarafModel().getRootDirectory().toString());
final StringBuffer vmArgs = new StringBuffer();
if (vmArgs.indexOf("-Declipse.application") == -1) { //$NON-NLS-1$
if (vmArgs.length() > 0) {
vmArgs.append(" "); //$NON-NLS-1$
}
vmArgs.append(" -Declipse.application=org.apache.karaf.eik.app.KarafMain"); //$NON-NLS-1$
}
try {
final String currentVMArguments = configuration.getAttribute(IJavaLaunchConfigurationConstants.ATTR_VM_ARGUMENTS, "");
if (currentVMArguments.trim().length() > 0) {
vmArgs.append(" ").append(currentVMArguments);
}
configuration.setAttribute(IJavaLaunchConfigurationConstants.ATTR_VM_ARGUMENTS, vmArgs.toString());
} catch (final CoreException e) {
KarafUIPluginActivator.getLogger().error("Unable to set default VM arguments", e);
}
}
@Override
public void launch(
final KarafWorkingPlatformModel platformModel,
final ILaunchConfiguration configuration,
final String mode,
final ILaunch launch,
final IProgressMonitor monitor) throws CoreException
{
if (!platformModel.getParentKarafModel().getClass().equals(GenericKarafPlatformModel.class)) {
return;
}
configureKarafFeatures(platformModel, configuration);
configureJMXConnector(platformModel);
}
private void addEclipseObrFile(
final KarafWorkingPlatformModel platformModel,
final Map<String, String> equinoxProperties) {
final IKarafProject karafProject = (IKarafProject) platformModel.getAdapter(IKarafProject.class);
// TODO: This should be factored out somehow
final IFile file = karafProject.getFile("platform/eclipse.obr.xml");
final IPath path = file.getRawLocation();
final String obr = equinoxProperties.get(IKarafConstants.KARAF_OBR_REPOSITORY_PROP);
if (obr.indexOf("eclipse.obr.xml") == -1) {
final String obrUrls;
if (obr.trim().length() > 1) {
obrUrls = obr + "," + "file://" + path.toFile().getAbsolutePath();
} else {
obrUrls = "file://" + path.toFile().getAbsolutePath();
}
equinoxProperties.put(
IKarafConstants.KARAF_OBR_REPOSITORY_PROP,
obrUrls);
}
}
private void configureJMXConnector(
final KarafWorkingPlatformModel platformModel) throws CoreException {
/*
* Ensure that the RMI registry port for the JMX connector is unique
*/
final int jmxRegistryPort = SocketUtil.findFreePort();
if (jmxRegistryPort == -1) {
throw new CoreException(new Status(
IStatus.ERROR,
KarafUIPluginActivator.PLUGIN_ID,
"Could not find suitable TCP/IP port for JMX RMI Registry"));
}
final ManagementSection managementSection =
(ManagementSection) platformModel.getAdapter(ManagementSection.class);
managementSection.load();
managementSection.setPort(jmxRegistryPort);
managementSection.save();
}
private void configureKarafFeatures(
final KarafWorkingPlatformModel platformModel, final ILaunchConfiguration configuration) throws CoreException {
if (!configuration.getAttribute(KarafLaunchConfigurationConstants.KARAF_LAUNCH_FEATURES_MANAGEMENT, true)) {
return;
}
final FeaturesSection featuresSection =
(FeaturesSection) platformModel.getAdapter(FeaturesSection.class);
featuresSection.load();
final String bootFeaturesString =
configuration.getAttribute(KarafLaunchConfigurationConstants.KARAF_LAUNCH_BOOT_FEATURES, ""); //$NON-NLS-1$
final String[] bootFeaturesArray = bootFeaturesString.split(",");
final List<String> features = new ArrayList<String>();
Collections.addAll(features, bootFeaturesArray);
featuresSection.setBootFeatureNames(features);
featuresSection.save();
}
private Properties createLaunchSystemProperties(
final KarafWorkingPlatformModel platformModel,
final ILaunchConfiguration configuration) throws CoreException {
final Properties systemProperties = loadSystemProperties(platformModel);
systemProperties.put(
IKarafConstants.KARAF_BASE_PROP,
platformModel.getParentKarafModel().getRootDirectory().toString());
systemProperties.put(
IKarafConstants.KARAF_HOME_PROP,
platformModel.getParentKarafModel().getRootDirectory().toString());
systemProperties.put(
"java.util.logging.config.file", //$NON-NLS-1$
platformModel.getParentKarafModel().getConfigurationDirectory().append("java.util.logging.properties").toString()); //$NON-NLS-1$
systemProperties.put(
IKarafConstants.KARAF_DATA_PROP,
platformModel.getParentKarafModel().getRootDirectory().append("data").toString()); //$NON-NLS-1$
systemProperties.put(
IKarafConstants.KARAF_INSTANCES_PROP,
platformModel.getParentKarafModel().getRootDirectory().append("instances").toString()); //$NON-NLS-1$
final Boolean startLocalConsole =
configuration.getAttribute(
KarafLaunchConfigurationConstants.KARAF_LAUNCH_START_LOCAL_CONSOLE,
true);
systemProperties.put(
"karaf.startLocalConsole", //$NON-NLS-1$
startLocalConsole.toString());
final Boolean startRemoteConsole =
configuration.getAttribute(
KarafLaunchConfigurationConstants.KARAF_LAUNCH_START_REMOTE_CONSOLE,
false);
systemProperties.put(
"karaf.startRemoteShell", //$NON-NLS-1$
startRemoteConsole.toString());
PropertyUtils.interpolateVariables(systemProperties, systemProperties);
return systemProperties;
}
private Properties loadSystemProperties(final KarafWorkingPlatformModel platformModel) {
try {
final Properties properties =
KarafCorePluginUtils.loadProperties(
platformModel.getParentKarafModel().getConfigurationDirectory().toFile(),
IKarafConstants.KARAF_DEFAULT_SYSTEM_PROPERTIES_FILE,
true);
return properties;
} catch(final CoreException e) {
KarafUIPluginActivator.getLogger().error("Unable to load configuration file: " + platformModel.getConfigurationDirectory(), e);
}
return new Properties();
}
}