| /*************************************************************************************************** |
| * Copyright (c) 2005 Eteration A.S. and Gorkem Ercan. All rights reserved. This program and the |
| * accompanying materials are made available under the terms of the Eclipse Public License v1.0 |
| * which accompanies this distribution, and is available at |
| * http://www.eclipse.org/legal/epl-v10.html |
| * |
| * Contributors: Gorkem Ercan - initial API and implementation |
| * |
| **************************************************************************************************/ |
| package org.eclipse.jst.server.generic.core.internal; |
| |
| import java.util.ArrayList; |
| import java.util.HashMap; |
| import java.util.Iterator; |
| import java.util.List; |
| import java.util.Map; |
| import org.eclipse.core.runtime.CoreException; |
| 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.DebugEvent; |
| import org.eclipse.debug.core.DebugPlugin; |
| import org.eclipse.debug.core.IDebugEventSetListener; |
| import org.eclipse.debug.core.ILaunch; |
| import org.eclipse.debug.core.ILaunchConfiguration; |
| import org.eclipse.debug.core.ILaunchConfigurationType; |
| import org.eclipse.debug.core.ILaunchConfigurationWorkingCopy; |
| import org.eclipse.debug.core.ILaunchManager; |
| import org.eclipse.debug.core.model.IProcess; |
| import org.eclipse.debug.ui.IDebugUIConstants; |
| import org.eclipse.jdt.launching.IJavaLaunchConfigurationConstants; |
| import org.eclipse.jdt.launching.IRuntimeClasspathEntry; |
| import org.eclipse.jdt.launching.IVMInstall; |
| import org.eclipse.jdt.launching.JavaRuntime; |
| import org.eclipse.jst.server.generic.servertype.definition.ArgumentPair; |
| import org.eclipse.jst.server.generic.servertype.definition.LaunchConfiguration; |
| import org.eclipse.jst.server.generic.servertype.definition.ServerRuntime; |
| import org.eclipse.osgi.util.NLS; |
| import org.eclipse.wst.server.core.IModule; |
| import org.eclipse.wst.server.core.IServer; |
| import org.eclipse.wst.server.core.ServerPort; |
| import org.eclipse.wst.server.core.internal.DeletedModule; |
| import org.eclipse.wst.server.core.model.ServerBehaviourDelegate; |
| import org.eclipse.wst.server.core.model.ServerDelegate; |
| import org.eclipse.wst.server.core.util.SocketUtil; |
| |
| /** |
| * Server behavior delegate implementation for generic server. |
| * |
| * @author Gorkem Ercan |
| */ |
| public class GenericServerBehaviour extends ServerBehaviourDelegate { |
| |
| public static final String ATTR_STOP = "stop-server"; //$NON-NLS-1$ |
| public static final String ATTR_SERVER_ID = "server-id"; //$NON-NLS-1$ |
| |
| // the thread used to ping the server to check for startup |
| protected transient PingThread ping; |
| protected transient IDebugEventSetListener processListener; |
| protected transient IProcess process; |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.wst.server.core.model.ServerBehaviourDelegate#publishServer(org.eclipse.core.runtime.IProgressMonitor) |
| */ |
| public void publishServer(int kind, IProgressMonitor monitor) throws CoreException { |
| // do nothing |
| } |
| |
| /* (non-Javadoc) |
| * @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) |
| */ |
| public void publishModule(int kind, int deltaKind, IModule[] module, |
| IProgressMonitor monitor) throws CoreException { |
| GenericPublisher publisher = initializePublisher( kind, deltaKind, module ); |
| IStatus[] status = null; |
| if(REMOVED == deltaKind ){//TODO: check if the removed module is published to server |
| status = publisher.unpublish(monitor); |
| } |
| else{ |
| checkClosed(module); |
| status= publisher.publish(null,monitor); |
| } |
| setModulePublishState( module, status ); |
| } |
| |
| private void setModulePublishState( IModule[] module, IStatus[] status ) throws CoreException { |
| if( module==null ) |
| return; |
| for( int i=0; i < module.length; i++) |
| { |
| if(status == null || |
| status.length < i || |
| status[i]==null || |
| status[i].getSeverity() == IStatus.OK ) |
| { |
| setModulePublishState(module, IServer.PUBLISH_STATE_NONE); |
| } |
| else |
| { |
| if ( IStatus.ERROR == status[i].getSeverity() ){ |
| setModulePublishState( module, IServer.PUBLISH_STATE_UNKNOWN ); |
| throw new CoreException( status[i] ); |
| } |
| } |
| } |
| } |
| |
| private void checkClosed(IModule[] module) throws CoreException |
| { |
| for( int i=0; i < module.length; i++ ){ |
| if( module[i] instanceof DeletedModule ){ |
| IStatus status = new Status(IStatus.ERROR,CorePlugin.PLUGIN_ID,0, NLS.bind(GenericServerCoreMessages.canNotPublishDeletedModule,module[i].getName()),null); |
| throw new CoreException(status); |
| } |
| } |
| } |
| |
| private GenericPublisher initializePublisher(int kind, int deltaKind, IModule[] module ) throws CoreException { |
| String publisherId = ServerTypeDefinitionUtil.getPublisherID(module[0], getServerDefinition()); |
| GenericPublisher publisher = PublishManager.getPublisher(publisherId); |
| if(publisher==null){ |
| IStatus status = new Status(IStatus.ERROR,CorePlugin.PLUGIN_ID,0,NLS.bind(GenericServerCoreMessages.unableToCreatePublisher,publisherId),null); |
| throw new CoreException(status); |
| } |
| publisher.initialize( module,getServer(), kind, deltaKind ); |
| return publisher; |
| } |
| |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.wst.server.core.model.ServerBehaviourDelegate#stop(boolean) |
| */ |
| public void stop(boolean force) { |
| if (force) { |
| terminate(); |
| return; |
| } |
| |
| int state = getServer().getServerState(); |
| if (state == IServer.STATE_STOPPED) |
| return; |
| else if (state == IServer.STATE_STARTING || state == IServer.STATE_STOPPING) { |
| terminate(); |
| return; |
| } |
| |
| shutdown(state); |
| } |
| |
| /** |
| * Shuts down the server via the launch configuration. |
| */ |
| protected void shutdown(int state) { |
| GenericServerRuntime runtime = getRuntimeDelegate(); |
| try { |
| Trace.trace(Trace.FINEST, "Stopping Server"); //$NON-NLS-1$ |
| if (state != IServer.STATE_STOPPED) |
| setServerState(IServer.STATE_STOPPING); |
| String configTypeID = getConfigTypeID(); |
| ILaunchManager mgr = DebugPlugin.getDefault().getLaunchManager(); |
| ILaunchConfigurationType type = mgr.getLaunchConfigurationType(configTypeID); |
| String launchName = getStopLaunchName(); |
| String uniqueLaunchName = mgr.generateUniqueLaunchConfigurationNameFrom(launchName); |
| ILaunchConfiguration conf = null; |
| ILaunchConfiguration[] lch = mgr.getLaunchConfigurations(type); |
| for (int i = 0; i < lch.length; i++) { |
| if (launchName.equals(lch[i].getName())) { |
| conf = lch[i]; |
| break; |
| } |
| } |
| |
| ILaunchConfigurationWorkingCopy wc = null; |
| if (conf != null) { |
| wc = conf.getWorkingCopy(); |
| } else { |
| wc = type.newInstance(null, uniqueLaunchName); |
| } |
| |
| // To stop from appearing in history lists |
| wc.setAttribute(IDebugUIConstants.ATTR_PRIVATE, true); |
| // Set the stop attribute so that we know we are stopping |
| wc.setAttribute(ATTR_STOP, "true"); //$NON-NLS-1$ |
| // Set the server ID so that we can distinguish stops |
| wc.setAttribute( ATTR_SERVER_ID, this.getServer().getId()); |
| // Setup the launch config for stopping the server |
| setupStopLaunchConfiguration(runtime, wc); |
| |
| // Launch the stop launch config |
| wc.launch(ILaunchManager.RUN_MODE, new NullProgressMonitor()); |
| |
| } catch (Exception e) { |
| Trace.trace(Trace.SEVERE, "Error stopping Server", e); //$NON-NLS-1$ |
| } |
| } |
| |
| /** |
| * Returns the String ID of the launch configuration type. |
| * @return id |
| */ |
| protected String getConfigTypeID() { |
| return IJavaLaunchConfigurationConstants.ID_JAVA_APPLICATION; |
| } |
| |
| /** |
| * Returns the String name of the stop launch configuration. |
| * @return launchname |
| */ |
| protected String getStopLaunchName() { |
| return "GenericServerStopper"; //$NON-NLS-1$ |
| } |
| |
| private boolean isRemote(){ |
| return (getServer().getServerType().supportsRemoteHosts()&& !SocketUtil.isLocalhost(getServer().getHost()) ); |
| } |
| /** |
| * Sets up the launch configuration for stopping the server. |
| */ |
| protected void setupStopLaunchConfiguration(GenericServerRuntime runtime, ILaunchConfigurationWorkingCopy wc) { |
| if(isRemote())// Do not launch for remote servers. |
| return; |
| |
| wc.setAttribute( |
| IJavaLaunchConfigurationConstants.ATTR_MAIN_TYPE_NAME, |
| getServerDefinition().getResolver().resolveProperties(this.getServerDefinition().getStop().getMainClass())); |
| |
| IVMInstall vmInstall = runtime.getVMInstall(); |
| wc.setAttribute( |
| IJavaLaunchConfigurationConstants.ATTR_VM_INSTALL_TYPE, runtime |
| .getVMInstallTypeId()); |
| wc.setAttribute( |
| IJavaLaunchConfigurationConstants.ATTR_VM_INSTALL_NAME, |
| vmInstall.getName()); |
| |
| setupLaunchClasspath(wc, vmInstall, getStopClasspath()); |
| |
| Map environVars = getEnvironmentVariables(getServerDefinition().getStop()); |
| if(!environVars.isEmpty()){ |
| wc.setAttribute(ILaunchManager.ATTR_ENVIRONMENT_VARIABLES,environVars); |
| } |
| |
| wc.setAttribute( |
| IJavaLaunchConfigurationConstants.ATTR_WORKING_DIRECTORY, |
| getServerDefinition().getResolver().resolveProperties(getServerDefinition().getStop().getWorkingDirectory())); |
| wc.setAttribute( |
| IJavaLaunchConfigurationConstants.ATTR_PROGRAM_ARGUMENTS, |
| getServerDefinition().getResolver().resolveProperties(getServerDefinition().getStop().getProgramArgumentsAsString())); |
| wc.setAttribute( |
| IJavaLaunchConfigurationConstants.ATTR_VM_ARGUMENTS, |
| getServerDefinition().getResolver().resolveProperties(getServerDefinition().getStop().getVmParametersAsString())); |
| } |
| |
| /** |
| * Start class name |
| * @return name |
| */ |
| public String getStartClassName() { |
| return getServerDefinition().getResolver().resolveProperties(getServerDefinition().getStart().getMainClass()); |
| } |
| |
| /** |
| * Server definition |
| * @return serverdef |
| */ |
| public ServerRuntime getServerDefinition() { |
| GenericServer server = (GenericServer)getServer().loadAdapter(ServerDelegate.class, null); |
| return server.getServerDefinition(); |
| } |
| |
| protected GenericServerRuntime getRuntimeDelegate() { |
| return (GenericServerRuntime)getServer().getRuntime().loadAdapter(GenericServerRuntime.class,null); |
| } |
| |
| private List getStartClasspath() { |
| String cpRef = getServerDefinition().getStart().getClasspathReference(); |
| return serverClasspath(cpRef); |
| } |
| |
| /** |
| * @param cpRef |
| * @return classpath |
| */ |
| protected List serverClasspath(String cpRef) { |
| return ServerTypeDefinitionUtil.getClasspathEntries(cpRef, getServerDefinition(),true); |
| } |
| |
| /** |
| * @param wc |
| * @param vmInstall |
| */ |
| protected void setupLaunchClasspath(ILaunchConfigurationWorkingCopy wc, IVMInstall vmInstall, List cp) { |
| //merge existing classpath with server classpath |
| try { |
| IRuntimeClasspathEntry[] existingCps = JavaRuntime.computeUnresolvedRuntimeClasspath(wc); |
| for (int i = 0; i < existingCps.length; i++) { |
| if(cp.contains(existingCps[i])==false){ |
| cp.add(existingCps[i]); |
| } |
| } |
| } catch (CoreException e) { |
| // ignore |
| } |
| |
| wc.setAttribute(IJavaLaunchConfigurationConstants.ATTR_CLASSPATH, convertCPEntryToMemento(cp)); |
| wc.setAttribute(IJavaLaunchConfigurationConstants.ATTR_DEFAULT_CLASSPATH,false); |
| } |
| |
| private List convertCPEntryToMemento(List cpEntryList) |
| { |
| List list = new ArrayList(cpEntryList.size()); |
| Iterator iterator = cpEntryList.iterator(); |
| while(iterator.hasNext()) |
| { |
| IRuntimeClasspathEntry entry = (IRuntimeClasspathEntry)iterator.next(); |
| try { |
| list.add(entry.getMemento()); |
| } catch (CoreException e) { |
| // ignore |
| } |
| } |
| return list; |
| } |
| |
| private String getWorkingDirectory() { |
| return getServerDefinition().getResolver().resolveProperties(getServerDefinition().getStart().getWorkingDirectory()); |
| } |
| |
| protected String getProgramArguments() { |
| return getServerDefinition().getResolver().resolveProperties(getServerDefinition().getStart().getProgramArgumentsAsString()); |
| } |
| |
| protected Map getEnvironmentVariables(LaunchConfiguration config){ |
| List variables = config.getEnvironmentVariable(); |
| Map varsMap = new HashMap(variables.size()); |
| Iterator iterator= variables.iterator(); |
| while(iterator.hasNext()){ |
| ArgumentPair pair = (ArgumentPair)iterator.next(); |
| varsMap.put(pair.getName(),getServerDefinition().getResolver().resolveProperties(pair.getValue())); |
| } |
| return varsMap; |
| } |
| |
| private String getVmArguments() { |
| return getServerDefinition().getResolver().resolveProperties(getServerDefinition().getStart().getVmParametersAsString()); |
| } |
| |
| public void setupLaunchConfiguration(ILaunchConfigurationWorkingCopy workingCopy, IProgressMonitor monitor) throws CoreException { |
| if(isRemote())// No launch for remote servers. |
| return; |
| |
| workingCopy.setAttribute( |
| IJavaLaunchConfigurationConstants.ATTR_MAIN_TYPE_NAME, |
| getStartClassName()); |
| |
| GenericServerRuntime runtime = getRuntimeDelegate(); |
| |
| IVMInstall vmInstall = runtime.getVMInstall(); |
| if (vmInstall == null ) vmInstall = JavaRuntime.getDefaultVMInstall(); |
| workingCopy.setAttribute( |
| IJavaLaunchConfigurationConstants.ATTR_JRE_CONTAINER_PATH, JavaRuntime.newJREContainerPath(vmInstall).toPortableString()); |
| |
| setupLaunchClasspath(workingCopy, vmInstall, getStartClasspath()); |
| |
| |
| workingCopy.setAttribute( |
| IJavaLaunchConfigurationConstants.ATTR_WORKING_DIRECTORY, |
| getWorkingDirectory()); |
| |
| |
| Map environVars = getEnvironmentVariables(getServerDefinition().getStart()); |
| if(!environVars.isEmpty()){ |
| workingCopy.setAttribute(ILaunchManager.ATTR_ENVIRONMENT_VARIABLES,environVars); |
| } |
| |
| String existingProgArgs = workingCopy.getAttribute(IJavaLaunchConfigurationConstants.ATTR_PROGRAM_ARGUMENTS, (String)null); |
| String serverProgArgs = getProgramArguments(); |
| if( existingProgArgs==null ) { |
| workingCopy.setAttribute(IJavaLaunchConfigurationConstants.ATTR_PROGRAM_ARGUMENTS,serverProgArgs); |
| } |
| String existingVMArgs = workingCopy.getAttribute(IJavaLaunchConfigurationConstants.ATTR_VM_ARGUMENTS,(String)null); |
| String serverVMArgs= getVmArguments(); |
| if( existingVMArgs==null ) { |
| workingCopy.setAttribute(IJavaLaunchConfigurationConstants.ATTR_VM_ARGUMENTS,serverVMArgs); |
| } |
| } |
| |
| /** |
| * Setup for starting the server. Checks all ports available |
| * and sets server state and mode. |
| * |
| * @param launch ILaunch |
| * @param launchMode String |
| * @param monitor IProgressMonitor |
| */ |
| protected void setupLaunch(ILaunch launch, String launchMode, IProgressMonitor monitor) throws CoreException { |
| if ("true".equals(launch.getLaunchConfiguration().getAttribute(ATTR_STOP, "false"))) //$NON-NLS-1$ //$NON-NLS-2$ |
| return; |
| |
| String host = getServer().getHost(); |
| ServerPort[] ports = getServer().getServerPorts(null); |
| ServerPort sp = null; |
| if(SocketUtil.isLocalhost(host)){ |
| for(int i=0;i<ports.length;i++){ |
| sp= ports[i]; |
| if (SocketUtil.isPortInUse(ports[i].getPort(), 5)) |
| throw new CoreException(new Status(IStatus.ERROR, CorePlugin.PLUGIN_ID, 0, NLS.bind(GenericServerCoreMessages.errorPortInUse,Integer.toString(sp.getPort()),sp.getName()),null)); |
| } |
| } |
| setServerState(IServer.STATE_STARTING); |
| setMode(launchMode); |
| } |
| /** |
| * Call to start Ping thread that will check for startup of the server. |
| * |
| */ |
| protected void startPingThread() |
| { |
| try { |
| String url = "http://"+getServer().getHost();; //$NON-NLS-1$ |
| ServerPort[] ports = getServer().getServerPorts(null); |
| ServerPort sp = null; |
| for(int i=0;i<ports.length;i++){ |
| if(ports[i].getProtocol().equalsIgnoreCase("http")){//$NON-NLS-1$ |
| sp=ports[i]; |
| } |
| } |
| if(sp==null){ |
| Trace.trace(Trace.SEVERE, "Can't ping for server startup."); //$NON-NLS-1$ |
| return; |
| } |
| int port = sp.getPort(); |
| if (port != 80) |
| url += ":" + port; //$NON-NLS-1$ |
| ping = new PingThread(getServer(), url, this); |
| } catch (Exception e) { |
| Trace.trace(Trace.SEVERE, "Can't ping for server startup."); //$NON-NLS-1$ |
| } |
| } |
| |
| protected void setProcess(final IProcess newProcess) { |
| if (process != null) |
| return; |
| if(processListener!=null) |
| DebugPlugin.getDefault().removeDebugEventListener(processListener); |
| if (newProcess==null) |
| return; |
| process = newProcess; |
| processListener = new IDebugEventSetListener() { |
| public void handleDebugEvents(DebugEvent[] events) { |
| if (events != null) { |
| int size = events.length; |
| for (int i = 0; i < size; i++) { |
| if (process!= null && process.equals(events[i].getSource()) && events[i].getKind() == DebugEvent.TERMINATE) { |
| DebugPlugin.getDefault().removeDebugEventListener(this); |
| stopImpl(); |
| } |
| } |
| } |
| } |
| }; |
| DebugPlugin.getDefault().addDebugEventListener(processListener); |
| } |
| |
| protected void stopImpl() { |
| if (ping != null) { |
| ping.stop(); |
| ping = null; |
| } |
| if (process != null) { |
| process = null; |
| DebugPlugin.getDefault().removeDebugEventListener(processListener); |
| processListener = null; |
| } |
| setServerState(IServer.STATE_STOPPED); |
| } |
| |
| /** |
| * Terminates the server. |
| * This method may be called before a process created while setting up the |
| * launch config. |
| */ |
| protected void terminate() { |
| if (getServer().getServerState() == IServer.STATE_STOPPED) |
| return; |
| |
| try { |
| setServerState(IServer.STATE_STOPPING); |
| Trace.trace(Trace.FINEST, "Killing the Server process"); //$NON-NLS-1$ |
| if (process != null && !process.isTerminated()) { |
| process.terminate(); |
| |
| } |
| stopImpl(); |
| } catch (Exception e) { |
| Trace.trace(Trace.SEVERE, "Error killing the process", e); //$NON-NLS-1$ |
| } |
| } |
| |
| private List getStopClasspath() { |
| String cpRef = getServerDefinition().getStop().getClasspathReference(); |
| return serverClasspath(cpRef); |
| } |
| |
| public void publishFinish(IProgressMonitor monitor) throws CoreException { |
| IModule[] modules = this.getServer().getModules(); |
| boolean allpublished= true; |
| for (int i = 0; i < modules.length; i++) { |
| if(this.getServer().getModulePublishState(new IModule[]{modules[i]})!=IServer.PUBLISH_STATE_NONE) |
| allpublished=false; |
| } |
| if(allpublished) |
| setServerPublishState(IServer.PUBLISH_STATE_NONE); |
| } |
| |
| protected void setServerStarted() { |
| setServerState(IServer.STATE_STARTED); |
| } |
| } |
