/*
* $Id$
* $HeadURL$
*
* ==============================================================================
* Licensed 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 runjettyrun;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStreamWriter;
import java.text.MessageFormat;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.HashSet;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
import org.eclipse.core.resources.IContainer;
import org.eclipse.core.resources.IFolder;
import org.eclipse.core.resources.IProject;
import org.eclipse.core.resources.IResource;
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.NullProgressMonitor;
import org.eclipse.core.runtime.Status;
import org.eclipse.debug.core.DebugException;
import org.eclipse.debug.core.ILaunch;
import org.eclipse.debug.core.ILaunchConfiguration;
import org.eclipse.debug.core.ILaunchConfigurationWorkingCopy;
import org.eclipse.debug.core.ILaunchManager;
import org.eclipse.debug.core.model.IProcess;
import org.eclipse.debug.core.sourcelookup.ISourceContainer;
import org.eclipse.debug.core.sourcelookup.ISourceLookupDirector;
import org.eclipse.debug.core.sourcelookup.containers.DefaultSourceContainer;
import org.eclipse.jdt.core.IJavaProject;
import org.eclipse.jdt.core.JavaCore;
import org.eclipse.jdt.internal.launching.JavaSourceLookupDirector;
import org.eclipse.jdt.launching.AbstractJavaLaunchConfigurationDelegate;
import org.eclipse.jdt.launching.ExecutionArguments;
import org.eclipse.jdt.launching.IRuntimeClasspathEntry;
import org.eclipse.jdt.launching.JavaRuntime;
import org.eclipse.jdt.launching.VMRunnerConfiguration;
import org.eclipse.jdt.launching.sourcelookup.containers.JavaProjectSourceContainer;
import runjettyrun.utils.ProjectUtil;
import runjettyrun.utils.RunJettyRunClasspathResolver;
import runjettyrun.utils.RunJettyRunClasspathUtil;
import runjettyrun.utils.RunJettyRunLaunchConfigurationUtil;
import runjettyrun.utils.RunJettyRunSourceLookupUtil;
/**
* Launch configuration type for Jetty. Based on
* org.eclipse.jdt.launching.JavaLaunchDelegate.
*
* @author hillenius
*/
public class JettyLaunchConfigurationType extends
AbstractJavaLaunchConfigurationDelegate {
private static HashMap<String, ILaunch> launcher = new HashMap<String, ILaunch>();
private JettyLaunchConfigurationClassPathProvider provider = new JettyLaunchConfigurationClassPathProvider();
/**
* Here's what the WebApp classpath. That means all the classpath here just
* like WEB-INF/classes or WEB-INF/lib , which is only for the specific
* webapp project and will not used for the Jetty Instance.
*
* @param configuration
* @return
* @throws CoreException
*/
private String getWebappClasspath(ILaunchConfiguration configuration)
throws CoreException {
String[] webAppClasspathArray = getProjectClasspath(configuration);
String webAppClasspath = "";
StringBuilder sb = new StringBuilder();
for (int i = 0; i < webAppClasspathArray.length; i++) {
String path = webAppClasspathArray[i];
if (sb.length() > 0)
sb.append(File.pathSeparator);
sb.append(path);
}
webAppClasspath = sb.toString();
/**
* The smallest limit for windows XP is 2048
*/
if (webAppClasspath.length() > 1024) {
File f = prepareClasspathFile(configuration, webAppClasspath);
webAppClasspath = "file://" + f.getAbsolutePath();
}
return webAppClasspath;
}
private String getScanlist(ILaunchConfiguration configuration) throws CoreException{
Set<String> paths = provider.getAllScanPathList(configuration);
Map<String,String> nonChecked = getAttributeFromLaunchConfiguration(configuration, Plugin.ATTR_SCAN_FOLDER_NON_CHECKED);
StringBuffer scanList = new StringBuffer();
for(String path:paths){
if(nonChecked.containsKey(path) && nonChecked.get(path).equals("1")){
continue;
}
if(!nonChecked.containsKey(path) && path.endsWith("test-classes")){
continue;
}
if (scanList.length() > 0){
scanList.append(File.pathSeparator);
}
scanList.append(path);
}
File f = prepareConfigFile(configuration, scanList.toString(),".scanlist");
return "file://" + f.getAbsolutePath();
}
/**
* Get working directory's absolute folder path.
*
* @param configuration
* @return return the path if exist, or return null.
* @throws CoreException
*/
private String getWorkingDirectoryAbsolutePath(
ILaunchConfiguration configuration) throws CoreException {
File workingDir = verifyWorkingDirectory(configuration);
String workingDirName = null;
if (workingDir != null)
workingDirName = workingDir.getAbsolutePath();
return workingDirName;
}
/**
* I prefer to change the name to JettyClasspath to make it more clear. This
* classpath means how the RunJettyRun to get the Jetty bundle.
*
* Note:it only used the USER_CLASSES classpaths , not including
* BOOTSTRAP_CLASSES. If you change the classpath , that might means you are
* changing the Jetty version or something on it.
*
* @param configuration
* @return
* @throws CoreException
*/
private String[] getJettyClasspath(ILaunchConfiguration configuration)
throws CoreException {
String[] paths = getResolvedJettyClasspath(configuration);
Set<String> finalPaths = new HashSet<String>();
for (String path : paths) {
finalPaths.add(path);
}
finalPaths.addAll(getJettyCustomClasspath(configuration));
Map<String,String> checked = getAttributeFromLaunchConfiguration(configuration, Plugin.ATTR_JETTY_CLASSPATH_NON_CHECKED);
HashSet<String> results = new HashSet<String>();
for (String path : finalPaths) {
if (!checked.containsKey(path) ||checked.get(path).equals("0")) {
results.add(path);
}
}
return results.toArray(new String[0]);
}
public String[] getResolvedJettyClasspath(ILaunchConfiguration configuration)
throws CoreException {
IRuntimeClasspathEntry[] entries = JavaRuntime
.computeUnresolvedRuntimeClasspath(configuration);
entries = JavaRuntime.resolveRuntimeClasspath(filterProejctEntries(entries), configuration);
List<String> userEntries = new ArrayList<String>(entries.length);
Set<String> set = new HashSet<String>(entries.length);
for (int i = 0; i < entries.length; i++) {
if (entries[i].getClasspathProperty() == IRuntimeClasspathEntry.USER_CLASSES) {
String location = entries[i].getLocation();
if (location != null) {
if (!set.contains(location)) {
userEntries.add(location);
set.add(location);
}
}
}
}
return (String[]) userEntries.toArray(new String[userEntries.size()]);
}
private IRuntimeClasspathEntry[] filterProejctEntries(IRuntimeClasspathEntry[] entries){
if(entries == null) {
return null;
}
List<IRuntimeClasspathEntry> items = new ArrayList<IRuntimeClasspathEntry>();
for(IRuntimeClasspathEntry entry:entries){
if(entry.getType() == IRuntimeClasspathEntry.PROJECT){
continue;
}
if(RunJettyRunClasspathUtil.isDefaultProjectClasspathEntry(entry)){
continue;
}
items.add(entry);
}
return items.toArray(new IRuntimeClasspathEntry[0]);
}
@SuppressWarnings("unchecked")
private Map<String,String> getAttributeFromLaunchConfiguration(
ILaunchConfiguration configuration, String attribute) {
Map<String,String> checked = null;
try {
checked = (Map<String,String>) configuration.getAttribute(attribute,
(Map<String,String>) null);
} catch (CoreException e) {
}
if(checked == null){
checked = new HashMap<String,String>();
}
return checked;
}
private Set<String> getCustomClasspath(ILaunchConfiguration configuration,
String attribute) throws CoreException {
IRuntimeClasspathEntry[] entries = provider
.computeUnresolvedCustomClasspath(configuration, attribute);
List<IRuntimeClasspathEntry> result = Arrays.asList(JavaRuntime.resolveRuntimeClasspath(entries, configuration));
Set<String> set = new HashSet<String>(result.size());
for (int i = 0; i < result.size(); i++) {
String location = result.get(i).getLocation();
if (location != null) {
if (!set.contains(location)) {
set.add(location);
}
}
}
return set;
}
private Set<String> getJettyCustomClasspath(
ILaunchConfiguration configuration) throws CoreException {
return getCustomClasspath(configuration,
Plugin.ATTR_JETTY_CUSTOM_CLASSPATH);
}
private Set<String> getWebappCustomClasspath(
ILaunchConfiguration configuration) throws CoreException {
return getCustomClasspath(configuration,
Plugin.ATTR_WEB_CONTEXT_CUSTOM_CLASSPATH);
}
/**
* get Runtime arguments , and prepare the webapp classpath for the program.
*
* @param configuration
* @param oringinalVMArguments
* @return
* @throws CoreException
*/
private String[] getRuntimeArguments(ILaunchConfiguration configuration,
String[] oringinalVMArguments,boolean debugMode)
throws CoreException {
List<String> runtimeVmArgs = getJettyArgs(configuration,debugMode);
boolean maxperm = false;
for (String str : oringinalVMArguments) {
if (str != null && str.indexOf("-XX:MaxPermSize") != -1)
maxperm = true;
}
if (!maxperm) {
runtimeVmArgs.add("-XX:MaxPermSize=128m");
}
// Here the classpath is really for web app.
runtimeVmArgs.add("-Drjrclasspath=" +
getWebappClasspath(configuration));
runtimeVmArgs.add("-Drjrscanlist=" + getScanlist(configuration));
runtimeVmArgs.add("-DrjrResourceMapping="
+ getLinkedResourceMapping(configuration));
if (Plugin.getDefault().isListenerEnable()) {
runtimeVmArgs.add("-DrjrEclipseListener="
+ Plugin.getDefault().getListenerPort());
}
runtimeVmArgs.addAll(Arrays.asList(oringinalVMArguments));
return runtimeVmArgs.toArray(new String[runtimeVmArgs.size()]);
}
private String getLinkedResourceInResource(IContainer root,
IContainer folder) {
StringBuffer sb = new StringBuffer();
try {
for (IResource ir : folder.members()) {
if (ir instanceof IFolder) {
if (ir.isLinked()) {
sb.append(ir.getProjectRelativePath().makeRelativeTo(
root.getProjectRelativePath())
+ "=" + ir.getLocation() + ";");
}
sb.append(getLinkedResourceInResource(root, (IFolder) ir));
}
}
} catch (CoreException e) {
e.printStackTrace();
}
return sb.toString();
}
private String getLinkedResourceMapping(ILaunchConfiguration conf) {
try {
IJavaProject proj = getJavaProject(conf);
String webappPath = conf.getAttribute(Plugin.ATTR_WEBAPPDIR, "");
if (proj == null || "".equals(webappPath))
return null;
IContainer webappDir = null;
if ("/".equals(webappPath)){
webappDir = proj.getProject();
}else{
webappDir = proj.getProject().getFolder(webappPath);
}
if (webappDir.exists()){
return getLinkedResourceInResource(webappDir, webappDir);
}
} catch (CoreException e) {
e.printStackTrace();
}
return null;
}
/**
* The launcher !
*/
public void launch(ILaunchConfiguration configuration, String mode,
ILaunch launch, IProgressMonitor monitor) throws CoreException {
/*
* for those terminate by our self .
*
* @see #terminateOldRJRLauncher
*/
if (!RunJettyRunLaunchConfigurationUtil.validation(configuration)) {
throw new CoreException(
new Status(
IStatus.ERROR,
Plugin.PLUGIN_ID,
01,
" Invalid run configuration , please check the configuration ",
null));
}
addSourcesLookupProjectsFromMavenIfExist(configuration);
if (monitor == null) {
monitor = new NullProgressMonitor();
}
monitor.beginTask(
MessageFormat.format("{0}...", configuration.getName()), 3); //$NON-NLS-1$
// check for cancellation
if (monitor.isCanceled())
return;
try {
monitor.subTask("verifying installation");
// Program & VM arguments
ExecutionArguments execArgs = new ExecutionArguments(
getVMArguments(configuration),
getProgramArguments(configuration));
// Create VM configuration
// here the classpath means for the Jetty Server , not for the
// application! by TonyQ 2011/3/7
VMRunnerConfiguration runConfig = new VMRunnerConfiguration(
Plugin.BOOTSTRAP_CLASS_NAME,
getJettyClasspath(configuration));
// logger to list classpaths
// for(String path:getJettyClasspath(configuration)){
// System.out.println("path:"+path);
// }
runConfig.setProgramArguments(execArgs.getProgramArgumentsArray());
// Environment variables
runConfig.setEnvironment(getEnvironment(configuration));
boolean debug = ILaunchManager.DEBUG_MODE.equals(mode);
// Here prepare the classpath is really for webapp in Runtime
// Arguments , too.
runConfig.setVMArguments(getRuntimeArguments(configuration,
execArgs.getVMArgumentsArray(),debug));
runConfig
.setWorkingDirectory(getWorkingDirectoryAbsolutePath(configuration));
runConfig
.setVMSpecificAttributesMap(getVMSpecificAttributesMap(configuration));
// Boot path
runConfig.setBootClassPath(getBootpath(configuration));
// check for cancellation
if (monitor.isCanceled())
return;
// stop in main
prepareStopInMain(configuration);
// done the verification phase
monitor.worked(1);
monitor.subTask("Creating source locator");
// set the default source locator if required
setDefaultSourceLocator(launch, configuration);
launch.getSourceLocator();
monitor.worked(1);
synchronized (configuration) {
terminateOldRJRLauncher(configuration, launch);
// Launch the configuration - 1 unit of work
getVMRunner(configuration, mode)
.run(runConfig, launch, monitor);
registerRJRLauncher(configuration, launch);
}
// check for cancellation
if (monitor.isCanceled())
return;
} finally {
monitor.done();
}
}
/**
* A private helper to prepare a classpath file to workspace metadata, we
* use this to prevent classpath too long which was caused the problem for
* reaching Windows command length limitation.
*
* @param configuration
* @param classpath
* @return
*/
private File prepareClasspathFile(ILaunchConfiguration configuration,
String classpath) {
return prepareConfigFile(configuration,classpath,".classpath");
}
private File prepareConfigFile(ILaunchConfiguration configuration,
String content ,String extension) {
IPath path = Plugin.getDefault().getStateLocation()
.append(configuration.getName() + extension);
File f = path.toFile();
try {
BufferedWriter out = new BufferedWriter(new OutputStreamWriter(
new FileOutputStream(f, false), "UTF8"));
out.write(content);
out.close();
return f;
} catch (IOException e) {
return null;
}
}
/**
* Terminate old Run-Jetty-Run launcher which use same port if exist.
*
* @param configuration
* @param launch
* @throws CoreException
*/
private static void terminateOldRJRLauncher(
ILaunchConfiguration configuration, ILaunch launch)
throws CoreException {
String port = configuration.getAttribute(Plugin.ATTR_PORT, "");
String sslPort = configuration.getAttribute(Plugin.ATTR_SSL_PORT, "");
boolean enableSSL = configuration.getAttribute(Plugin.ATTR_ENABLE_SSL,
false);
if (!"".equals(port) && launcher.containsKey(port)) {
terminateLaunch(launcher.get(port));
launcher.remove(port);
}
if (enableSSL && !"".equals(sslPort) && launcher.containsKey(sslPort)) {
terminateLaunch(launcher.get(sslPort));
launcher.remove(sslPort);
}
}
private static void terminateLaunch(ILaunch launch) throws DebugException {
if (!launch.isTerminated()) {
IProcess[] processes = launch.getProcesses();
if (processes != null) {
for (IProcess proc : processes) {
if (proc != null)
proc.terminate();
}
}
}
}
/**
* register a port for RJR Launcher
*
* @param configuration
* @param launch
* @throws CoreException
*/
private static void registerRJRLauncher(ILaunchConfiguration configuration,
ILaunch launch) throws CoreException {
String port = configuration.getAttribute(Plugin.ATTR_PORT, "");
String sslPort = configuration.getAttribute(Plugin.ATTR_SSL_PORT, "");
boolean enableSSL = configuration.getAttribute(Plugin.ATTR_ENABLE_SSL,
false);
if (!"".equals(port))
launcher.put(port, launch);
if (enableSSL && !"".equals(sslPort))
launcher.put(sslPort, launch);
}
private List<String> getJettyArgs(ILaunchConfiguration configuration,boolean debugMode)
throws CoreException {
List<String> runtimeVmArgs = new ArrayList<String>();
addOptionalAttr(configuration, runtimeVmArgs, Plugin.ATTR_CONTEXT,
"context");
addWebappAttr(configuration, runtimeVmArgs, Plugin.ATTR_WEBAPPDIR);
addOptionalAttr(configuration, runtimeVmArgs, Plugin.ATTR_PORT, "port");
addOptionalAttr(configuration, runtimeVmArgs, Plugin.ATTR_SSL_PORT,
"sslport");
addOptionalAttr(configuration, runtimeVmArgs, Plugin.ATTR_KEYSTORE,
"keystore");
addOptionalAttr(configuration, runtimeVmArgs, Plugin.ATTR_KEY_PWD,
"keypassword");
addOptionalAttr(configuration, runtimeVmArgs, Plugin.ATTR_PWD,
"password");
addOptionalAttr(configuration, runtimeVmArgs,
Plugin.ATTR_JETTY_XML_PATH, "jettyXMLPath");
addOptionalAttr(configuration, runtimeVmArgs,
Plugin.ATTR_SCANINTERVALSECONDS, "scanintervalseconds");
addOptionalAttrx(configuration, runtimeVmArgs,
Plugin.ATTR_ENABLE_SCANNER, "enablescanner");
if(debugMode){
addOptionalAttrx(configuration, runtimeVmArgs, Plugin.ATTR_IGNORE_SCAN_CLASS_WHEN_DEBUG_MODE,
"ignoreScanClassFile",true);
}
addOptionalAttrx(configuration, runtimeVmArgs, Plugin.ATTR_ENABLE_SSL,
"enablessl");
addOptionalAttrx(configuration, runtimeVmArgs,
Plugin.ATTR_ENABLE_NEED_CLIENT_AUTH, "needclientauth");
addOptionalAttrx(configuration, runtimeVmArgs,
Plugin.ATTR_ENABLE_PARENT_LOADER_PRIORITY,
"parentloaderpriority");
addOptionalAttrx(configuration, runtimeVmArgs, Plugin.ATTR_ENABLE_JNDI,
"enbaleJNDI");
return runtimeVmArgs;
}
private void addWebappAttr(ILaunchConfiguration configuration,
List<String> runtimeVmArgs, String cfgAttr) throws CoreException {
IJavaProject proj = this.getJavaProject(configuration);
if (proj == null)
return;
String value = configuration.getAttribute(cfgAttr, "");
if ("/".equals(value)) {
IPath path = (IPath) proj.getResource().getLocation().clone();
path.makeAbsolute();
value = path.toOSString();
} else {
if (proj.getProject().getFolder(value).getLocation() == null) {
throw new IllegalStateException(
"raw location shouldn't be null");
}
value = proj.getProject().getFolder(value).getLocation()
.toOSString();
}
if (value.length() == 0)
return;
String arg = "-Drjr" + "webapp" + "=" + value + "";
runtimeVmArgs.add(arg);
return;
}
private void addOptionalAttr(ILaunchConfiguration configuration,
List<String> runtimeVmArgs, String cfgAttr, String argName)
throws CoreException {
String value = configuration.getAttribute(cfgAttr, "");
if (value.length() == 0)
return;
String arg = "-Drjr" + argName + "=" + value;
runtimeVmArgs.add(arg);
return;
}
private void addOptionalAttrx(ILaunchConfiguration configuration,
List<String> runtimeVmArgs, String cfgAttr, String argName,boolean defVal)
throws CoreException {
Boolean value = configuration.getAttribute(cfgAttr, defVal);
String arg = "-Drjr" + argName + "=" + value;
runtimeVmArgs.add(arg);
return;
}
private void addOptionalAttrx(ILaunchConfiguration configuration,
List<String> runtimeVmArgs, String cfgAttr, String argName)
throws CoreException {
addOptionalAttrx(configuration,runtimeVmArgs,cfgAttr,argName,false);
}
/**
* Returns the class path to be used by the web app context (not by Jetty,
* or as JRE Bootstrap).
* <p>
* Added by James Synge.
*
* Copied from {@link AbstractJavaLaunchConfigurationDelegate} so that I can
* eliminate everything that should be in WEB-INF/lib, but is not supposed
* to be in the project's classpath.
*
* (non-Javadoc)
*
* @see org.eclipse.jdt.launching.AbstractJavaLaunchConfigurationDelegate#getClasspath(org.eclipse.debug.core.ILaunchConfiguration)
*/
private String[] getProjectClasspath(ILaunchConfiguration configuration)
throws CoreException {
try {
IRuntimeClasspathEntry[] entries = RunJettyRunClasspathUtil.getDefaultWebAppClasspaths(configuration);
entries = RunJettyRunClasspathResolver.resolveClasspath(entries,
configuration);
// entries = JavaRuntime.resolveRuntimeClasspath(entries,
// configuration);
Set<String> locations = searchUserClass(entries);
locations.addAll(getWebappCustomClasspath(configuration));
locations.addAll(RunJettyRunClasspathUtil.getWebInfLibLocations(configuration));
List<String> result = new ArrayList<String>();
Map<String,String> checked = getAttributeFromLaunchConfiguration(configuration, Plugin.ATTR_WEB_CONTEXT_CLASSPATH_NON_CHECKED);
addResult(result,locations,checked,true);
return (String[]) result.toArray(new String[0]);
} catch (IllegalArgumentException e) {
return new String[0];
}
}
private void addResult(List<String> result,Set<String> locations,Map<String,String> checked,boolean ignoreTestClassesByDefault){
for(String item:locations){
if(!checked.containsKey(item) ){
if(ignoreTestClassesByDefault && item.endsWith("test-classes")){
result.add("-n-"+item);
}else{
result.add("-y-"+item);
}
}else if(checked.get(item).equals("0")){
result.add("-y-"+item);
}else{
result.add("-n-"+item);
}
}
}
/**
* add project sources into ILaunchConfiguration which are referenced by
* maven
*
* Referenced from yanyilin224.
* @param configuration
*/
private void addSourcesLookupProjectsFromMavenIfExist(ILaunchConfiguration configuration) {
try {
IJavaProject curProject = JavaRuntime.getJavaProject(configuration);
boolean isMaven = ProjectUtil.isMavenProject(curProject.getProject());
if(!isMaven ) {
return ;
}
List<IProject> projs = RunJettyRunSourceLookupUtil.findMavenRelatedProjects(configuration);
if(projs.size() == 0 ){
return ;
}
ISourceLookupDirector sourceDir = new JavaSourceLookupDirector();
ILaunchConfigurationWorkingCopy workCopy = configuration.getWorkingCopy();
String initMemento = workCopy.getAttribute(
ILaunchConfiguration.ATTR_SOURCE_LOCATOR_MEMENTO, "");
if (initMemento != null && !initMemento.trim().equals("")) {
sourceDir.initializeFromMemento(initMemento);
}
ISourceContainer[] existContainers = sourceDir
.getSourceContainers();
List<ISourceContainer> realContainers = new ArrayList<ISourceContainer>();
//add exsits source containers
for (ISourceContainer container : existContainers) {
realContainers.add(container);
}
//check default source container
ISourceContainer defaultContainer = new DefaultSourceContainer();
if (!contains(existContainers, defaultContainer)) {
realContainers.add(defaultContainer);
}
for (IProject dependency : projs) {
// handle projects in current workspace
ISourceContainer newContainer = new JavaProjectSourceContainer(
JavaCore.create((IProject) dependency));
if (!contains(existContainers, newContainer)) {
realContainers.add(newContainer);
}
}
sourceDir.setSourceContainers(realContainers
.toArray(new ISourceContainer[realContainers.size()]));
workCopy.setAttribute(
ILaunchConfiguration.ATTR_SOURCE_LOCATOR_MEMENTO,
sourceDir.getMemento());
workCopy.doSave();
} catch (Exception e) {
// something wrong, skip add sources
}
}
/**
* if containers contains target source container
*
* @param containers
* exsited source containers
* @param target
* @return
*/
private boolean contains(ISourceContainer[] containers,
ISourceContainer target) {
String name = target.getName();
String type = target.getType().getId();
for (ISourceContainer container : containers) {
if (name.equals(container.getName())
&& type.equals(container.getType().getId())) {
return true;
}
}
return false;
}
private Set<String> searchUserClass(IRuntimeClasspathEntry[] entries) {
Set<String> locations = new LinkedHashSet<String>();
for (int i = 0; i < entries.length; i++) {
IRuntimeClasspathEntry entry = entries[i];
if (entry.getClasspathProperty() == IRuntimeClasspathEntry.USER_CLASSES) {
String location = entry.getLocation();
if (location != null) {
locations.add(location);
}
}
}
return locations;
}
}