gercan | be0fd05 | 2005-11-08 21:47:59 +0000 | [diff] [blame] | 1 | /*************************************************************************************************** |
| 2 | * Copyright (c) 2005 Eteration A.S. and Gorkem Ercan. All rights reserved. This program and the |
| 3 | * accompanying materials are made available under the terms of the Eclipse Public License v1.0 |
gercan | 53c00bb | 2005-05-18 19:54:52 +0000 | [diff] [blame] | 4 | * which accompanies this distribution, and is available at |
gercan | be0fd05 | 2005-11-08 21:47:59 +0000 | [diff] [blame] | 5 | * http://www.eclipse.org/legal/epl-v10.html |
gercan | 53c00bb | 2005-05-18 19:54:52 +0000 | [diff] [blame] | 6 | * |
gercan | be0fd05 | 2005-11-08 21:47:59 +0000 | [diff] [blame] | 7 | * Contributors: Gorkem Ercan - initial API and implementation |
| 8 | * |
| 9 | **************************************************************************************************/ |
gercan | 6644034 | 2005-03-08 22:20:47 +0000 | [diff] [blame] | 10 | package org.eclipse.jst.server.generic.core.internal; |
gercan | 202cf23 | 2004-12-04 11:58:11 +0000 | [diff] [blame] | 11 | |
| 12 | import java.util.ArrayList; |
gercan | a8a90f4 | 2005-08-30 21:47:29 +0000 | [diff] [blame] | 13 | import java.util.HashMap; |
gercan | 202cf23 | 2004-12-04 11:58:11 +0000 | [diff] [blame] | 14 | import java.util.Iterator; |
| 15 | import java.util.List; |
gercan | a8a90f4 | 2005-08-30 21:47:29 +0000 | [diff] [blame] | 16 | import java.util.Map; |
gercan | 202cf23 | 2004-12-04 11:58:11 +0000 | [diff] [blame] | 17 | import org.eclipse.core.runtime.CoreException; |
gercan | 202cf23 | 2004-12-04 11:58:11 +0000 | [diff] [blame] | 18 | import org.eclipse.core.runtime.IProgressMonitor; |
| 19 | import org.eclipse.core.runtime.IStatus; |
| 20 | import org.eclipse.core.runtime.NullProgressMonitor; |
| 21 | import org.eclipse.core.runtime.Path; |
| 22 | import org.eclipse.core.runtime.Status; |
| 23 | import org.eclipse.debug.core.DebugEvent; |
| 24 | import org.eclipse.debug.core.DebugPlugin; |
| 25 | import org.eclipse.debug.core.IDebugEventSetListener; |
| 26 | import org.eclipse.debug.core.ILaunch; |
| 27 | import org.eclipse.debug.core.ILaunchConfiguration; |
| 28 | import org.eclipse.debug.core.ILaunchConfigurationType; |
| 29 | import org.eclipse.debug.core.ILaunchConfigurationWorkingCopy; |
| 30 | import org.eclipse.debug.core.ILaunchManager; |
| 31 | import org.eclipse.debug.core.model.IProcess; |
| 32 | import org.eclipse.debug.ui.IDebugUIConstants; |
| 33 | import org.eclipse.jdt.launching.IJavaLaunchConfigurationConstants; |
| 34 | import org.eclipse.jdt.launching.IRuntimeClasspathEntry; |
| 35 | import org.eclipse.jdt.launching.IVMInstall; |
| 36 | import org.eclipse.jdt.launching.JavaRuntime; |
gercan | 202cf23 | 2004-12-04 11:58:11 +0000 | [diff] [blame] | 37 | import org.eclipse.jst.server.generic.servertype.definition.ArchiveType; |
gercan | a8a90f4 | 2005-08-30 21:47:29 +0000 | [diff] [blame] | 38 | import org.eclipse.jst.server.generic.servertype.definition.ArgumentPair; |
gercan | 202cf23 | 2004-12-04 11:58:11 +0000 | [diff] [blame] | 39 | import org.eclipse.jst.server.generic.servertype.definition.Classpath; |
gercan | a8a90f4 | 2005-08-30 21:47:29 +0000 | [diff] [blame] | 40 | import org.eclipse.jst.server.generic.servertype.definition.LaunchConfiguration; |
gercan | 202cf23 | 2004-12-04 11:58:11 +0000 | [diff] [blame] | 41 | import org.eclipse.jst.server.generic.servertype.definition.ServerRuntime; |
gercan | d6f4c0d | 2006-02-20 18:48:49 +0000 | [diff] [blame] | 42 | import org.eclipse.osgi.util.NLS; |
gercan | 202cf23 | 2004-12-04 11:58:11 +0000 | [diff] [blame] | 43 | import org.eclipse.wst.server.core.IModule; |
| 44 | import org.eclipse.wst.server.core.IServer; |
gercan | 4b6c9a6 | 2005-03-23 06:08:30 +0000 | [diff] [blame] | 45 | import org.eclipse.wst.server.core.ServerPort; |
gercan | 8995a6c | 2005-11-17 20:42:39 +0000 | [diff] [blame] | 46 | import org.eclipse.wst.server.core.internal.DeletedModule; |
gercan | 202cf23 | 2004-12-04 11:58:11 +0000 | [diff] [blame] | 47 | import org.eclipse.wst.server.core.model.ServerBehaviourDelegate; |
| 48 | import org.eclipse.wst.server.core.model.ServerDelegate; |
gercan | 202cf23 | 2004-12-04 11:58:11 +0000 | [diff] [blame] | 49 | import org.eclipse.wst.server.core.util.SocketUtil; |
| 50 | |
| 51 | /** |
gercan | de114e1 | 2004-12-06 23:07:27 +0000 | [diff] [blame] | 52 | * Server behaviour delegate implementation for generic server. |
gercan | 202cf23 | 2004-12-04 11:58:11 +0000 | [diff] [blame] | 53 | * |
| 54 | * @author Gorkem Ercan |
| 55 | */ |
| 56 | public class GenericServerBehaviour extends ServerBehaviourDelegate { |
| 57 | |
gercan | 8995a6c | 2005-11-17 20:42:39 +0000 | [diff] [blame] | 58 | private static final String ATTR_STOP = "stop-server"; //$NON-NLS-1$ |
gercan | 202cf23 | 2004-12-04 11:58:11 +0000 | [diff] [blame] | 59 | |
| 60 | // the thread used to ping the server to check for startup |
| 61 | protected transient PingThread ping = null; |
| 62 | protected transient IDebugEventSetListener processListener; |
| 63 | protected transient IProcess process; |
| 64 | |
| 65 | /* (non-Javadoc) |
| 66 | * @see org.eclipse.wst.server.core.model.ServerBehaviourDelegate#publishServer(org.eclipse.core.runtime.IProgressMonitor) |
| 67 | */ |
gercan | c380c80 | 2005-02-02 21:20:40 +0000 | [diff] [blame] | 68 | public void publishServer(int kind, IProgressMonitor monitor) throws CoreException { |
gercan | 53c00bb | 2005-05-18 19:54:52 +0000 | [diff] [blame] | 69 | // do nothing |
gercan | 202cf23 | 2004-12-04 11:58:11 +0000 | [diff] [blame] | 70 | } |
| 71 | |
| 72 | /* (non-Javadoc) |
| 73 | * @see org.eclipse.wst.server.core.model.ServerBehaviourDelegate#publishModule(org.eclipse.wst.server.core.IModule[], org.eclipse.wst.server.core.IModule, org.eclipse.core.runtime.IProgressMonitor) |
| 74 | */ |
gercan | 980ddcb | 2005-03-16 17:58:09 +0000 | [diff] [blame] | 75 | public void publishModule(int kind, int deltaKind, IModule[] module, |
gercan | 202cf23 | 2004-12-04 11:58:11 +0000 | [diff] [blame] | 76 | IProgressMonitor monitor) throws CoreException { |
gercan | d742243 | 2005-01-30 21:54:27 +0000 | [diff] [blame] | 77 | |
gercan | 7c052dd | 2006-06-04 19:01:29 +0000 | [diff] [blame] | 78 | |
gercan | 4b6c9a6 | 2005-03-23 06:08:30 +0000 | [diff] [blame] | 79 | if(REMOVED == deltaKind){ |
gercan | 1a49877 | 2005-03-07 22:07:00 +0000 | [diff] [blame] | 80 | removeFromServer(module,monitor); |
gercan | d742243 | 2005-01-30 21:54:27 +0000 | [diff] [blame] | 81 | } |
gercan | 1a49877 | 2005-03-07 22:07:00 +0000 | [diff] [blame] | 82 | else{ |
gercan | 7c052dd | 2006-06-04 19:01:29 +0000 | [diff] [blame] | 83 | checkClosed(module); |
gercan | 68b3acf | 2005-10-24 18:40:50 +0000 | [diff] [blame] | 84 | String publisherId = ServerTypeDefinitionUtil.getPublisherID(module[0], getServerDefinition()); |
gercan | 1a49877 | 2005-03-07 22:07:00 +0000 | [diff] [blame] | 85 | GenericPublisher publisher = PublishManager.getPublisher(publisherId); |
| 86 | if(publisher==null){ |
gercan | d6f4c0d | 2006-02-20 18:48:49 +0000 | [diff] [blame] | 87 | IStatus status = new Status(IStatus.ERROR,CorePlugin.PLUGIN_ID,0, NLS.bind(GenericServerCoreMessages.unableToCreatePublisher,publisherId),null); |
gercan | 1a49877 | 2005-03-07 22:07:00 +0000 | [diff] [blame] | 88 | throw new CoreException(status); |
| 89 | } |
gercan | 91da920 | 2005-06-22 20:44:10 +0000 | [diff] [blame] | 90 | publisher.initialize(module,getServer()); |
gercan | 1a49877 | 2005-03-07 22:07:00 +0000 | [diff] [blame] | 91 | IStatus[] status= publisher.publish(null,monitor); |
gercan | 726fc72 | 2005-07-18 18:34:17 +0000 | [diff] [blame] | 92 | if(status==null){ |
gercan | 980ddcb | 2005-03-16 17:58:09 +0000 | [diff] [blame] | 93 | setModulePublishState(module, IServer.PUBLISH_STATE_NONE); |
gercan | 726fc72 | 2005-07-18 18:34:17 +0000 | [diff] [blame] | 94 | }else { |
| 95 | for (int i=0; i < status.length; i++) { |
| 96 | if (IStatus.ERROR == status[i].getSeverity()){ |
| 97 | setModulePublishState(module, IServer.PUBLISH_STATE_UNKNOWN); |
| 98 | throw new CoreException(status[i]); |
| 99 | } |
| 100 | } |
| 101 | } |
gercan | 1a49877 | 2005-03-07 22:07:00 +0000 | [diff] [blame] | 102 | } |
gercan | 202cf23 | 2004-12-04 11:58:11 +0000 | [diff] [blame] | 103 | } |
| 104 | |
gercan | 8995a6c | 2005-11-17 20:42:39 +0000 | [diff] [blame] | 105 | private void checkClosed(IModule[] module) throws CoreException |
| 106 | { |
| 107 | for(int i=0;i<module.length;i++) |
| 108 | { |
| 109 | if(module[i] instanceof DeletedModule) |
| 110 | { |
gercan | d6f4c0d | 2006-02-20 18:48:49 +0000 | [diff] [blame] | 111 | IStatus status = new Status(IStatus.ERROR,CorePlugin.PLUGIN_ID,0, NLS.bind(GenericServerCoreMessages.canNotPublishDeletedModule,module[i].getName()),null); |
gercan | 8995a6c | 2005-11-17 20:42:39 +0000 | [diff] [blame] | 112 | throw new CoreException(status); |
| 113 | } |
| 114 | } |
| 115 | } |
gercan | 980ddcb | 2005-03-16 17:58:09 +0000 | [diff] [blame] | 116 | private void removeFromServer(IModule[] module, IProgressMonitor monitor) throws CoreException |
gercan | 1a49877 | 2005-03-07 22:07:00 +0000 | [diff] [blame] | 117 | { |
gercan | 68b3acf | 2005-10-24 18:40:50 +0000 | [diff] [blame] | 118 | String publisherId = ServerTypeDefinitionUtil.getPublisherID(module[0], getServerDefinition()); |
gercan | 1a49877 | 2005-03-07 22:07:00 +0000 | [diff] [blame] | 119 | GenericPublisher publisher = PublishManager.getPublisher(publisherId); |
| 120 | if(publisher==null){ |
gercan | d6f4c0d | 2006-02-20 18:48:49 +0000 | [diff] [blame] | 121 | IStatus status = new Status(IStatus.ERROR,CorePlugin.PLUGIN_ID,0,NLS.bind(GenericServerCoreMessages.unableToCreatePublisher,publisherId),null); |
gercan | 1a49877 | 2005-03-07 22:07:00 +0000 | [diff] [blame] | 122 | throw new CoreException(status); |
| 123 | } |
gercan | 91da920 | 2005-06-22 20:44:10 +0000 | [diff] [blame] | 124 | publisher.initialize(module,getServer()); |
gercan | 1a49877 | 2005-03-07 22:07:00 +0000 | [diff] [blame] | 125 | publisher.unpublish(monitor); |
| 126 | } |
| 127 | |
| 128 | |
gercan | 202cf23 | 2004-12-04 11:58:11 +0000 | [diff] [blame] | 129 | /* (non-Javadoc) |
| 130 | * @see org.eclipse.wst.server.core.model.ServerBehaviourDelegate#stop(boolean) |
| 131 | */ |
gercan | 202cf23 | 2004-12-04 11:58:11 +0000 | [diff] [blame] | 132 | public void stop(boolean force) { |
| 133 | if (force) { |
| 134 | terminate(); |
| 135 | return; |
| 136 | } |
| 137 | |
| 138 | int state = getServer().getServerState(); |
| 139 | if (state == IServer.STATE_STOPPED) |
| 140 | return; |
| 141 | else if (state == IServer.STATE_STARTING || state == IServer.STATE_STOPPING) { |
| 142 | terminate(); |
| 143 | return; |
| 144 | } |
gercan | c733492 | 2005-06-16 15:51:50 +0000 | [diff] [blame] | 145 | |
| 146 | shutdown(state); |
| 147 | } |
| 148 | |
| 149 | /** |
| 150 | * Shuts down the server via the launch configuration. |
| 151 | */ |
| 152 | protected void shutdown(int state) { |
gercan | f97307f | 2005-11-16 21:54:19 +0000 | [diff] [blame] | 153 | GenericServerRuntime runtime = getRuntimeDelegate(); |
gercan | 202cf23 | 2004-12-04 11:58:11 +0000 | [diff] [blame] | 154 | try { |
gercan | 8995a6c | 2005-11-17 20:42:39 +0000 | [diff] [blame] | 155 | Trace.trace(Trace.FINEST, "Stopping Server"); //$NON-NLS-1$ |
gercan | 202cf23 | 2004-12-04 11:58:11 +0000 | [diff] [blame] | 156 | if (state != IServer.STATE_STOPPED) |
| 157 | setServerState(IServer.STATE_STOPPING); |
gercan | c733492 | 2005-06-16 15:51:50 +0000 | [diff] [blame] | 158 | String configTypeID = getConfigTypeID(); |
gercan | 202cf23 | 2004-12-04 11:58:11 +0000 | [diff] [blame] | 159 | ILaunchManager mgr = DebugPlugin.getDefault().getLaunchManager(); |
gercan | c733492 | 2005-06-16 15:51:50 +0000 | [diff] [blame] | 160 | ILaunchConfigurationType type = mgr.getLaunchConfigurationType(configTypeID); |
| 161 | String launchName = getStopLaunchName(); |
| 162 | String uniqueLaunchName = mgr.generateUniqueLaunchConfigurationNameFrom(launchName); |
gercan | 202cf23 | 2004-12-04 11:58:11 +0000 | [diff] [blame] | 163 | ILaunchConfiguration conf = null; |
gercan | 202cf23 | 2004-12-04 11:58:11 +0000 | [diff] [blame] | 164 | ILaunchConfiguration[] lch = mgr.getLaunchConfigurations(type); |
| 165 | for (int i = 0; i < lch.length; i++) { |
| 166 | if (launchName.equals(lch[i].getName())) { |
| 167 | conf = lch[i]; |
| 168 | break; |
| 169 | } |
| 170 | } |
| 171 | |
| 172 | ILaunchConfigurationWorkingCopy wc = null; |
| 173 | if (conf != null) { |
| 174 | wc = conf.getWorkingCopy(); |
| 175 | } else { |
| 176 | wc = type.newInstance(null, uniqueLaunchName); |
| 177 | } |
gercan | c733492 | 2005-06-16 15:51:50 +0000 | [diff] [blame] | 178 | |
| 179 | // To stop from appearing in history lists |
| 180 | wc.setAttribute(IDebugUIConstants.ATTR_PRIVATE, true); |
| 181 | // Set the stop attribute so that we know we are stopping |
gercan | 8995a6c | 2005-11-17 20:42:39 +0000 | [diff] [blame] | 182 | wc.setAttribute(ATTR_STOP, "true"); //$NON-NLS-1$ |
gercan | c733492 | 2005-06-16 15:51:50 +0000 | [diff] [blame] | 183 | |
| 184 | // Setup the launch config for stopping the server |
| 185 | setupStopLaunchConfiguration(runtime, wc); |
| 186 | |
| 187 | // Launch the stop launch config |
gercan | 202cf23 | 2004-12-04 11:58:11 +0000 | [diff] [blame] | 188 | wc.launch(ILaunchManager.RUN_MODE, new NullProgressMonitor()); |
gercan | c733492 | 2005-06-16 15:51:50 +0000 | [diff] [blame] | 189 | |
gercan | 202cf23 | 2004-12-04 11:58:11 +0000 | [diff] [blame] | 190 | } catch (Exception e) { |
gercan | 8995a6c | 2005-11-17 20:42:39 +0000 | [diff] [blame] | 191 | Trace.trace(Trace.SEVERE, "Error stopping Server", e); //$NON-NLS-1$ |
gercan | 202cf23 | 2004-12-04 11:58:11 +0000 | [diff] [blame] | 192 | } |
gercan | 202cf23 | 2004-12-04 11:58:11 +0000 | [diff] [blame] | 193 | } |
| 194 | |
gercan | c733492 | 2005-06-16 15:51:50 +0000 | [diff] [blame] | 195 | /** |
| 196 | * Returns the String ID of the launch configuration type. |
gercan | 51230b9 | 2006-04-02 21:15:34 +0000 | [diff] [blame] | 197 | * @return id |
gercan | c733492 | 2005-06-16 15:51:50 +0000 | [diff] [blame] | 198 | */ |
| 199 | protected String getConfigTypeID() { |
| 200 | return IJavaLaunchConfigurationConstants.ID_JAVA_APPLICATION; |
| 201 | } |
| 202 | |
| 203 | /** |
| 204 | * Returns the String name of the stop launch configuration. |
gercan | 51230b9 | 2006-04-02 21:15:34 +0000 | [diff] [blame] | 205 | * @return launchname |
gercan | c733492 | 2005-06-16 15:51:50 +0000 | [diff] [blame] | 206 | */ |
| 207 | protected String getStopLaunchName() { |
gercan | 8995a6c | 2005-11-17 20:42:39 +0000 | [diff] [blame] | 208 | return "GenericServerStopper"; //$NON-NLS-1$ |
gercan | c733492 | 2005-06-16 15:51:50 +0000 | [diff] [blame] | 209 | } |
| 210 | |
gercan | f97307f | 2005-11-16 21:54:19 +0000 | [diff] [blame] | 211 | private boolean isRemote(){ |
| 212 | return (getServer().getServerType().supportsRemoteHosts()&& !SocketUtil.isLocalhost(getServer().getHost()) ); |
| 213 | } |
gercan | c733492 | 2005-06-16 15:51:50 +0000 | [diff] [blame] | 214 | /** |
| 215 | * Sets up the launch configuration for stopping the server. |
gercan | c733492 | 2005-06-16 15:51:50 +0000 | [diff] [blame] | 216 | */ |
| 217 | protected void setupStopLaunchConfiguration(GenericServerRuntime runtime, ILaunchConfigurationWorkingCopy wc) { |
gercan | f97307f | 2005-11-16 21:54:19 +0000 | [diff] [blame] | 218 | if(isRemote())// Do not launch for remote servers. |
| 219 | return; |
| 220 | |
gercan | c733492 | 2005-06-16 15:51:50 +0000 | [diff] [blame] | 221 | wc.setAttribute( |
| 222 | IJavaLaunchConfigurationConstants.ATTR_MAIN_TYPE_NAME, |
| 223 | getServerDefinition().getResolver().resolveProperties(this.getServerDefinition().getStop().getMainClass())); |
| 224 | |
| 225 | IVMInstall vmInstall = runtime.getVMInstall(); |
| 226 | wc.setAttribute( |
| 227 | IJavaLaunchConfigurationConstants.ATTR_VM_INSTALL_TYPE, runtime |
| 228 | .getVMInstallTypeId()); |
| 229 | wc.setAttribute( |
| 230 | IJavaLaunchConfigurationConstants.ATTR_VM_INSTALL_NAME, |
| 231 | vmInstall.getName()); |
| 232 | |
| 233 | setupLaunchClasspath(wc, vmInstall, getStopClasspath()); |
| 234 | |
gercan | a8a90f4 | 2005-08-30 21:47:29 +0000 | [diff] [blame] | 235 | Map environVars = getEnvironmentVariables(getServerDefinition().getStop()); |
| 236 | if(!environVars.isEmpty()){ |
| 237 | wc.setAttribute(ILaunchManager.ATTR_ENVIRONMENT_VARIABLES,environVars); |
| 238 | } |
| 239 | |
gercan | c733492 | 2005-06-16 15:51:50 +0000 | [diff] [blame] | 240 | wc.setAttribute( |
| 241 | IJavaLaunchConfigurationConstants.ATTR_WORKING_DIRECTORY, |
| 242 | getServerDefinition().getResolver().resolveProperties(getServerDefinition().getStop().getWorkingDirectory())); |
| 243 | wc.setAttribute( |
| 244 | IJavaLaunchConfigurationConstants.ATTR_PROGRAM_ARGUMENTS, |
gercan | a8a90f4 | 2005-08-30 21:47:29 +0000 | [diff] [blame] | 245 | getServerDefinition().getResolver().resolveProperties(getServerDefinition().getStop().getProgramArgumentsAsString())); |
gercan | c733492 | 2005-06-16 15:51:50 +0000 | [diff] [blame] | 246 | wc.setAttribute( |
| 247 | IJavaLaunchConfigurationConstants.ATTR_VM_ARGUMENTS, |
gercan | a8a90f4 | 2005-08-30 21:47:29 +0000 | [diff] [blame] | 248 | getServerDefinition().getResolver().resolveProperties(getServerDefinition().getStop().getVmParametersAsString())); |
gercan | c733492 | 2005-06-16 15:51:50 +0000 | [diff] [blame] | 249 | } |
| 250 | |
gercan | 51230b9 | 2006-04-02 21:15:34 +0000 | [diff] [blame] | 251 | /** |
| 252 | * Start class name |
| 253 | * @return name |
| 254 | */ |
gercan | 202cf23 | 2004-12-04 11:58:11 +0000 | [diff] [blame] | 255 | public String getStartClassName() { |
gercan | 2284dc2 | 2005-03-27 12:57:33 +0000 | [diff] [blame] | 256 | return getServerDefinition().getResolver().resolveProperties(getServerDefinition().getStart().getMainClass()); |
gercan | 202cf23 | 2004-12-04 11:58:11 +0000 | [diff] [blame] | 257 | } |
| 258 | |
gercan | 51230b9 | 2006-04-02 21:15:34 +0000 | [diff] [blame] | 259 | /** |
| 260 | * Server definition |
| 261 | * @return serverdef |
| 262 | */ |
gercan | 202cf23 | 2004-12-04 11:58:11 +0000 | [diff] [blame] | 263 | public ServerRuntime getServerDefinition() { |
gercan | 3a09773 | 2005-06-14 04:16:07 +0000 | [diff] [blame] | 264 | GenericServer server = (GenericServer)getServer().loadAdapter(ServerDelegate.class, null); |
gercan | 202cf23 | 2004-12-04 11:58:11 +0000 | [diff] [blame] | 265 | return server.getServerDefinition(); |
| 266 | } |
| 267 | |
gercan | c733492 | 2005-06-16 15:51:50 +0000 | [diff] [blame] | 268 | protected GenericServerRuntime getRuntimeDelegate() { |
gercan | 14d0e65 | 2005-06-12 19:35:28 +0000 | [diff] [blame] | 269 | return (GenericServerRuntime)getServer().getRuntime().loadAdapter(GenericServerRuntime.class,null); |
gercan | 202cf23 | 2004-12-04 11:58:11 +0000 | [diff] [blame] | 270 | } |
| 271 | |
gercan | 202cf23 | 2004-12-04 11:58:11 +0000 | [diff] [blame] | 272 | private List getStartClasspath() { |
| 273 | String cpRef = getServerDefinition().getStart().getClasspathReference(); |
| 274 | return serverClasspath(cpRef); |
| 275 | } |
| 276 | |
| 277 | /** |
| 278 | * @param cpRef |
gercan | 51230b9 | 2006-04-02 21:15:34 +0000 | [diff] [blame] | 279 | * @return classpath |
gercan | 202cf23 | 2004-12-04 11:58:11 +0000 | [diff] [blame] | 280 | */ |
gercan | 412f727 | 2005-05-26 22:28:45 +0000 | [diff] [blame] | 281 | protected List serverClasspath(String cpRef) { |
gercan | 202cf23 | 2004-12-04 11:58:11 +0000 | [diff] [blame] | 282 | Classpath classpath = getServerDefinition().getClasspath(cpRef); |
| 283 | |
gercan | 2dfb488 | 2005-04-18 19:32:07 +0000 | [diff] [blame] | 284 | List cpEntryList = new ArrayList(classpath.getArchive().size()); |
gercan | 202cf23 | 2004-12-04 11:58:11 +0000 | [diff] [blame] | 285 | Iterator iterator= classpath.getArchive().iterator(); |
| 286 | while(iterator.hasNext()) |
| 287 | { |
| 288 | ArchiveType archive = (ArchiveType)iterator.next(); |
| 289 | String cpath = getServerDefinition().getResolver().resolveProperties(archive.getPath()); |
gercan | 2dfb488 | 2005-04-18 19:32:07 +0000 | [diff] [blame] | 290 | |
| 291 | cpEntryList.add(JavaRuntime.newArchiveRuntimeClasspathEntry( |
| 292 | new Path(cpath))); |
| 293 | } |
| 294 | return cpEntryList; |
gercan | 202cf23 | 2004-12-04 11:58:11 +0000 | [diff] [blame] | 295 | } |
| 296 | |
| 297 | /** |
| 298 | * @param wc |
| 299 | * @param vmInstall |
| 300 | */ |
gercan | 412f727 | 2005-05-26 22:28:45 +0000 | [diff] [blame] | 301 | protected void setupLaunchClasspath(ILaunchConfigurationWorkingCopy wc, IVMInstall vmInstall, List cp) { |
gercan | 2dfb488 | 2005-04-18 19:32:07 +0000 | [diff] [blame] | 302 | //merge existing classpath with server classpath |
| 303 | try { |
| 304 | IRuntimeClasspathEntry[] existingCps = JavaRuntime.computeUnresolvedRuntimeClasspath(wc); |
| 305 | for (int i = 0; i < existingCps.length; i++) { |
| 306 | if(cp.contains(existingCps[i])==false){ |
| 307 | cp.add(existingCps[i]); |
| 308 | } |
| 309 | } |
| 310 | } catch (CoreException e) { |
| 311 | // ignore |
| 312 | } |
| 313 | |
| 314 | wc.setAttribute(IJavaLaunchConfigurationConstants.ATTR_CLASSPATH, convertCPEntryToMemento(cp)); |
| 315 | wc.setAttribute(IJavaLaunchConfigurationConstants.ATTR_DEFAULT_CLASSPATH,false); |
| 316 | } |
| 317 | |
| 318 | private List convertCPEntryToMemento(List cpEntryList) |
| 319 | { |
| 320 | List list = new ArrayList(cpEntryList.size()); |
| 321 | Iterator iterator = cpEntryList.iterator(); |
| 322 | while(iterator.hasNext()) |
| 323 | { |
| 324 | IRuntimeClasspathEntry entry = (IRuntimeClasspathEntry)iterator.next(); |
| 325 | try { |
| 326 | list.add(entry.getMemento()); |
| 327 | } catch (CoreException e) { |
| 328 | // ignore |
| 329 | } |
| 330 | } |
| 331 | return list; |
| 332 | } |
gercan | 202cf23 | 2004-12-04 11:58:11 +0000 | [diff] [blame] | 333 | |
| 334 | private String getWorkingDirectory() { |
| 335 | return getServerDefinition().getResolver().resolveProperties(getServerDefinition().getStart().getWorkingDirectory()); |
| 336 | } |
| 337 | |
gercan | fbe9cb4 | 2006-01-21 13:14:53 +0000 | [diff] [blame] | 338 | protected String getProgramArguments() { |
gercan | a8a90f4 | 2005-08-30 21:47:29 +0000 | [diff] [blame] | 339 | return getServerDefinition().getResolver().resolveProperties(getServerDefinition().getStart().getProgramArgumentsAsString()); |
gercan | 202cf23 | 2004-12-04 11:58:11 +0000 | [diff] [blame] | 340 | } |
| 341 | |
gercan | a8a90f4 | 2005-08-30 21:47:29 +0000 | [diff] [blame] | 342 | protected Map getEnvironmentVariables(LaunchConfiguration config){ |
| 343 | List variables = config.getEnvironmentVariable(); |
| 344 | Map varsMap = new HashMap(variables.size()); |
| 345 | Iterator iterator= variables.iterator(); |
| 346 | while(iterator.hasNext()){ |
| 347 | ArgumentPair pair = (ArgumentPair)iterator.next(); |
| 348 | varsMap.put(pair.getName(),getServerDefinition().getResolver().resolveProperties(pair.getValue())); |
| 349 | } |
| 350 | return varsMap; |
| 351 | } |
| 352 | |
gercan | 202cf23 | 2004-12-04 11:58:11 +0000 | [diff] [blame] | 353 | private String getVmArguments() { |
gercan | a8a90f4 | 2005-08-30 21:47:29 +0000 | [diff] [blame] | 354 | return getServerDefinition().getResolver().resolveProperties(getServerDefinition().getStart().getVmParametersAsString()); |
gercan | 202cf23 | 2004-12-04 11:58:11 +0000 | [diff] [blame] | 355 | } |
| 356 | |
gercan | c733492 | 2005-06-16 15:51:50 +0000 | [diff] [blame] | 357 | public void setupLaunchConfiguration(ILaunchConfigurationWorkingCopy workingCopy, IProgressMonitor monitor) throws CoreException { |
gercan | f97307f | 2005-11-16 21:54:19 +0000 | [diff] [blame] | 358 | if(isRemote())// No launch for remote servers. |
| 359 | return; |
| 360 | |
| 361 | workingCopy.setAttribute( |
gercan | d742243 | 2005-01-30 21:54:27 +0000 | [diff] [blame] | 362 | IJavaLaunchConfigurationConstants.ATTR_MAIN_TYPE_NAME, |
| 363 | getStartClassName()); |
| 364 | |
gercan | f97307f | 2005-11-16 21:54:19 +0000 | [diff] [blame] | 365 | GenericServerRuntime runtime = getRuntimeDelegate(); |
gercan | d742243 | 2005-01-30 21:54:27 +0000 | [diff] [blame] | 366 | |
| 367 | IVMInstall vmInstall = runtime.getVMInstall(); |
| 368 | workingCopy.setAttribute( |
| 369 | IJavaLaunchConfigurationConstants.ATTR_VM_INSTALL_TYPE, runtime |
| 370 | .getVMInstallTypeId()); |
| 371 | workingCopy.setAttribute( |
| 372 | IJavaLaunchConfigurationConstants.ATTR_VM_INSTALL_NAME, |
| 373 | vmInstall.getName()); |
| 374 | |
| 375 | setupLaunchClasspath(workingCopy, vmInstall, getStartClasspath()); |
| 376 | |
| 377 | |
| 378 | workingCopy.setAttribute( |
| 379 | IJavaLaunchConfigurationConstants.ATTR_WORKING_DIRECTORY, |
| 380 | getWorkingDirectory()); |
gercan | ec6ef21 | 2005-02-17 06:14:42 +0000 | [diff] [blame] | 381 | |
gercan | a8a90f4 | 2005-08-30 21:47:29 +0000 | [diff] [blame] | 382 | |
| 383 | Map environVars = getEnvironmentVariables(getServerDefinition().getStart()); |
| 384 | if(!environVars.isEmpty()){ |
| 385 | workingCopy.setAttribute(ILaunchManager.ATTR_ENVIRONMENT_VARIABLES,environVars); |
| 386 | } |
| 387 | |
gercan | ec6ef21 | 2005-02-17 06:14:42 +0000 | [diff] [blame] | 388 | String existingProgArgs = workingCopy.getAttribute(IJavaLaunchConfigurationConstants.ATTR_PROGRAM_ARGUMENTS, (String)null); |
| 389 | String serverProgArgs = getProgramArguments(); |
| 390 | if(existingProgArgs==null || existingProgArgs.indexOf(serverProgArgs)<0) { |
| 391 | workingCopy.setAttribute(IJavaLaunchConfigurationConstants.ATTR_PROGRAM_ARGUMENTS,serverProgArgs); |
| 392 | } |
| 393 | String existingVMArgs = workingCopy.getAttribute(IJavaLaunchConfigurationConstants.ATTR_VM_ARGUMENTS,(String)null); |
| 394 | String serverVMArgs= getVmArguments(); |
| 395 | if(existingVMArgs==null || existingVMArgs.indexOf(serverVMArgs)<0) { |
| 396 | workingCopy.setAttribute(IJavaLaunchConfigurationConstants.ATTR_VM_ARGUMENTS,serverVMArgs); |
| 397 | } |
gercan | 879fdab | 2005-06-13 21:30:14 +0000 | [diff] [blame] | 398 | } |
gercan | 202cf23 | 2004-12-04 11:58:11 +0000 | [diff] [blame] | 399 | |
gercan | c733492 | 2005-06-16 15:51:50 +0000 | [diff] [blame] | 400 | /** |
gercan | 714985d | 2006-04-29 21:08:06 +0000 | [diff] [blame] | 401 | * Setup for starting the server. Checks all ports available |
| 402 | * and sets server state and mode. |
gercan | c733492 | 2005-06-16 15:51:50 +0000 | [diff] [blame] | 403 | * |
| 404 | * @param launch ILaunch |
| 405 | * @param launchMode String |
| 406 | * @param monitor IProgressMonitor |
| 407 | */ |
| 408 | protected void setupLaunch(ILaunch launch, String launchMode, IProgressMonitor monitor) throws CoreException { |
gercan | 8995a6c | 2005-11-17 20:42:39 +0000 | [diff] [blame] | 409 | if ("true".equals(launch.getLaunchConfiguration().getAttribute(ATTR_STOP, "false"))) //$NON-NLS-1$ //$NON-NLS-2$ |
gercan | c733492 | 2005-06-16 15:51:50 +0000 | [diff] [blame] | 410 | return; |
gercan | e231f4f | 2005-08-10 20:08:06 +0000 | [diff] [blame] | 411 | |
gercan | d9cdddc | 2005-10-06 03:41:05 +0000 | [diff] [blame] | 412 | String host = getServer().getHost(); |
gercan | c733492 | 2005-06-16 15:51:50 +0000 | [diff] [blame] | 413 | ServerPort[] ports = getServer().getServerPorts(null); |
| 414 | ServerPort sp = null; |
gercan | a479bb4 | 2006-05-13 22:01:37 +0000 | [diff] [blame] | 415 | if(SocketUtil.isLocalhost(host)){ |
gercan | d9cdddc | 2005-10-06 03:41:05 +0000 | [diff] [blame] | 416 | for(int i=0;i<ports.length;i++){ |
| 417 | sp= ports[i]; |
| 418 | if (SocketUtil.isPortInUse(ports[i].getPort(), 5)) |
gercan | d6f4c0d | 2006-02-20 18:48:49 +0000 | [diff] [blame] | 419 | throw new CoreException(new Status(IStatus.ERROR, CorePlugin.PLUGIN_ID, 0, NLS.bind(GenericServerCoreMessages.errorPortInUse,Integer.toString(sp.getPort()),sp.getName()),null)); |
gercan | d9cdddc | 2005-10-06 03:41:05 +0000 | [diff] [blame] | 420 | } |
gercan | 202cf23 | 2004-12-04 11:58:11 +0000 | [diff] [blame] | 421 | } |
gercan | c733492 | 2005-06-16 15:51:50 +0000 | [diff] [blame] | 422 | setServerState(IServer.STATE_STARTING); |
| 423 | setMode(launchMode); |
gercan | 714985d | 2006-04-29 21:08:06 +0000 | [diff] [blame] | 424 | } |
| 425 | /** |
| 426 | * Call to start Ping thread that will check for startup of the server. |
| 427 | * |
| 428 | */ |
| 429 | protected void startPingThread() |
| 430 | { |
gercan | c733492 | 2005-06-16 15:51:50 +0000 | [diff] [blame] | 431 | try { |
gercan | 714985d | 2006-04-29 21:08:06 +0000 | [diff] [blame] | 432 | String url = "http://"+getServer().getHost();; //$NON-NLS-1$ |
| 433 | ServerPort[] ports = getServer().getServerPorts(null); |
| 434 | ServerPort sp = null; |
| 435 | for(int i=0;i<ports.length;i++){ |
| 436 | if(ports[i].getProtocol().equalsIgnoreCase("http")){//$NON-NLS-1$ |
| 437 | sp=ports[i]; |
| 438 | } |
| 439 | } |
| 440 | if(sp==null){ |
| 441 | Trace.trace(Trace.SEVERE, "Can't ping for server startup."); //$NON-NLS-1$ |
| 442 | return; |
| 443 | } |
| 444 | int port = sp.getPort(); |
gercan | c733492 | 2005-06-16 15:51:50 +0000 | [diff] [blame] | 445 | if (port != 80) |
gercan | 8995a6c | 2005-11-17 20:42:39 +0000 | [diff] [blame] | 446 | url += ":" + port; //$NON-NLS-1$ |
gercan | c5d7c03 | 2005-06-21 22:20:17 +0000 | [diff] [blame] | 447 | ping = new PingThread(getServer(), url, this); |
gercan | c733492 | 2005-06-16 15:51:50 +0000 | [diff] [blame] | 448 | } catch (Exception e) { |
gercan | 8995a6c | 2005-11-17 20:42:39 +0000 | [diff] [blame] | 449 | Trace.trace(Trace.SEVERE, "Can't ping for server startup."); //$NON-NLS-1$ |
gercan | 714985d | 2006-04-29 21:08:06 +0000 | [diff] [blame] | 450 | } |
gercan | c733492 | 2005-06-16 15:51:50 +0000 | [diff] [blame] | 451 | } |
gercan | 714985d | 2006-04-29 21:08:06 +0000 | [diff] [blame] | 452 | |
gercan | 412f727 | 2005-05-26 22:28:45 +0000 | [diff] [blame] | 453 | protected void setProcess(final IProcess newProcess) { |
gercan | 202cf23 | 2004-12-04 11:58:11 +0000 | [diff] [blame] | 454 | if (process != null) |
| 455 | return; |
gercan | cbfe4a5 | 2005-06-05 21:37:17 +0000 | [diff] [blame] | 456 | if(processListener!=null) |
| 457 | DebugPlugin.getDefault().removeDebugEventListener(processListener); |
| 458 | if (newProcess==null) |
| 459 | return; |
gercan | 202cf23 | 2004-12-04 11:58:11 +0000 | [diff] [blame] | 460 | process = newProcess; |
| 461 | processListener = new IDebugEventSetListener() { |
| 462 | public void handleDebugEvents(DebugEvent[] events) { |
| 463 | if (events != null) { |
| 464 | int size = events.length; |
| 465 | for (int i = 0; i < size; i++) { |
gercan | cbfe4a5 | 2005-06-05 21:37:17 +0000 | [diff] [blame] | 466 | if (process!= null && process.equals(events[i].getSource()) && events[i].getKind() == DebugEvent.TERMINATE) { |
gercan | 202cf23 | 2004-12-04 11:58:11 +0000 | [diff] [blame] | 467 | DebugPlugin.getDefault().removeDebugEventListener(this); |
| 468 | stopImpl(); |
| 469 | } |
| 470 | } |
| 471 | } |
| 472 | } |
| 473 | }; |
| 474 | DebugPlugin.getDefault().addDebugEventListener(processListener); |
| 475 | } |
| 476 | |
| 477 | protected void stopImpl() { |
| 478 | if (ping != null) { |
gercan | 53c00bb | 2005-05-18 19:54:52 +0000 | [diff] [blame] | 479 | ping.stop(); |
gercan | 202cf23 | 2004-12-04 11:58:11 +0000 | [diff] [blame] | 480 | ping = null; |
| 481 | } |
| 482 | if (process != null) { |
| 483 | process = null; |
| 484 | DebugPlugin.getDefault().removeDebugEventListener(processListener); |
| 485 | processListener = null; |
| 486 | } |
| 487 | setServerState(IServer.STATE_STOPPED); |
| 488 | } |
| 489 | |
| 490 | /** |
| 491 | * Terminates the server. |
gercan | e231f4f | 2005-08-10 20:08:06 +0000 | [diff] [blame] | 492 | * This method may be called before a process created while setting up the |
| 493 | * launch config. |
gercan | 202cf23 | 2004-12-04 11:58:11 +0000 | [diff] [blame] | 494 | */ |
gercan | c733492 | 2005-06-16 15:51:50 +0000 | [diff] [blame] | 495 | protected void terminate() { |
gercan | 202cf23 | 2004-12-04 11:58:11 +0000 | [diff] [blame] | 496 | if (getServer().getServerState() == IServer.STATE_STOPPED) |
| 497 | return; |
| 498 | |
| 499 | try { |
| 500 | setServerState(IServer.STATE_STOPPING); |
gercan | 8995a6c | 2005-11-17 20:42:39 +0000 | [diff] [blame] | 501 | Trace.trace(Trace.FINEST, "Killing the Server process"); //$NON-NLS-1$ |
gercan | 202cf23 | 2004-12-04 11:58:11 +0000 | [diff] [blame] | 502 | if (process != null && !process.isTerminated()) { |
| 503 | process.terminate(); |
gercan | e231f4f | 2005-08-10 20:08:06 +0000 | [diff] [blame] | 504 | |
gercan | 202cf23 | 2004-12-04 11:58:11 +0000 | [diff] [blame] | 505 | } |
gercan | e231f4f | 2005-08-10 20:08:06 +0000 | [diff] [blame] | 506 | stopImpl(); |
gercan | 202cf23 | 2004-12-04 11:58:11 +0000 | [diff] [blame] | 507 | } catch (Exception e) { |
gercan | 8995a6c | 2005-11-17 20:42:39 +0000 | [diff] [blame] | 508 | Trace.trace(Trace.SEVERE, "Error killing the process", e); //$NON-NLS-1$ |
gercan | 202cf23 | 2004-12-04 11:58:11 +0000 | [diff] [blame] | 509 | } |
| 510 | } |
| 511 | |
| 512 | private List getStopClasspath() { |
| 513 | String cpRef = getServerDefinition().getStop().getClasspathReference(); |
| 514 | return serverClasspath(cpRef); |
| 515 | } |
gercan | 7b2057b | 2005-06-14 04:53:15 +0000 | [diff] [blame] | 516 | |
gercan | ec6ef21 | 2005-02-17 06:14:42 +0000 | [diff] [blame] | 517 | public void publishFinish(IProgressMonitor monitor) throws CoreException { |
| 518 | IModule[] modules = this.getServer().getModules(); |
| 519 | boolean allpublished= true; |
| 520 | for (int i = 0; i < modules.length; i++) { |
gercan | 6400a65 | 2005-07-08 22:25:46 +0000 | [diff] [blame] | 521 | if(this.getServer().getModulePublishState(new IModule[]{modules[i]})!=IServer.PUBLISH_STATE_NONE) |
gercan | ec6ef21 | 2005-02-17 06:14:42 +0000 | [diff] [blame] | 522 | allpublished=false; |
| 523 | } |
| 524 | if(allpublished) |
| 525 | setServerPublishState(IServer.PUBLISH_STATE_NONE); |
| 526 | } |
gercan | 53c00bb | 2005-05-18 19:54:52 +0000 | [diff] [blame] | 527 | |
| 528 | protected void setServerStarted() { |
| 529 | setServerState(IServer.STATE_STARTED); |
| 530 | } |
| 531 | } |