| /********************************************************************** |
| * Copyright (c) 2003, 2011 IBM Corporation and others. |
| * 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: |
| * IBM Corporation - Initial API and implementation |
| **********************************************************************/ |
| package org.eclipse.wst.server.core; |
| |
| import java.util.*; |
| |
| import org.eclipse.core.resources.*; |
| import org.eclipse.core.runtime.CoreException; |
| import org.eclipse.core.runtime.IProgressMonitor; |
| import org.eclipse.core.runtime.IStatus; |
| import org.eclipse.core.runtime.jobs.ISchedulingRule; |
| import org.eclipse.debug.core.ILaunchConfiguration; |
| |
| import org.eclipse.osgi.util.NLS; |
| import org.eclipse.wst.server.core.internal.*; |
| /** |
| * Server utility methods. These static methods can be used to perform |
| * common operations on server artifacts. |
| * <p> |
| * This class provides all its functionality through static members. |
| * It is not intended to be sub-classed or instantiated. |
| * </p> |
| * @since 1.0 |
| */ |
| public class ServerUtil { |
| /** |
| * Constant identifying the job family identifier for server operations. |
| * |
| * @see org.eclipse.core.runtime.jobs.IJobManager#join(Object, IProgressMonitor) |
| * @since 2.0 |
| */ |
| public static final Object SERVER_JOB_FAMILY = ServerPlugin.PLUGIN_ID; |
| |
| /** |
| * Static utility class - cannot create an instance. |
| */ |
| private ServerUtil() { |
| // can't create |
| } |
| |
| /** |
| * Returns the module contained within the given project. If more than one module |
| * is contained with the project, this method will return an arbitrary module |
| * unless the module factory defines an ordering. If there might be multiple |
| * modules in a project, users should typically use getModules(IProject) instead. |
| * <p> |
| * This method may trigger bundle loading and is not suitable for |
| * short/UI operations. |
| * </p> |
| * |
| * @param project a project |
| * @return a module that is contained with the project, or null if no |
| * modules are contained in the given project |
| * @see #getModules(IProject) |
| */ |
| public static IModule getModule(IProject project) { |
| if (project == null) |
| throw new IllegalArgumentException(); |
| |
| IModule[] modules = getModules(project); |
| if (modules != null && modules.length > 0) |
| return modules[0]; |
| |
| return null; |
| } |
| |
| /** |
| * Returns the modules contained within the given project. |
| * <p> |
| * This method may trigger bundle loading and is not suitable for |
| * short/UI operations. |
| * </p> |
| * |
| * @param project a project |
| * @return a possibly-empty array of modules |
| * @see #getModule(IProject) |
| */ |
| public static IModule[] getModules(IProject project) { |
| if (project == null) |
| throw new IllegalArgumentException(); |
| |
| // use a set for better contains() performance |
| List<IModule> list = new ArrayList<IModule>(); |
| |
| ModuleFactory[] factories = ServerPlugin.getModuleFactories(); |
| |
| if (factories != null) { |
| for (ModuleFactory factory : factories) { |
| if (factory.isEnabled(project, null)){ |
| IModule[] modules = factory.getModules(project, null); |
| if (modules != null) { |
| for (IModule module : modules) { |
| if (!list.contains(module)) |
| list.add(module); |
| } |
| } |
| } |
| } |
| } |
| return list.toArray(new IModule[list.size()]); |
| } |
| |
| /** |
| * Returns the module with the given moduleId, if one exists. The moduleId |
| * must not be null. |
| * <p> |
| * This method may trigger bundle loading and is not suitable for |
| * short/UI operations. |
| * </p> |
| * |
| * @param moduleId a module id |
| * @return the module, or <code>null</code> if the module could not be found |
| */ |
| public static IModule getModule(String moduleId) { |
| if (moduleId == null) |
| throw new IllegalArgumentException(); |
| |
| int index = moduleId.indexOf(":"); |
| if (index <= 0) |
| return null; |
| |
| String factoryId = moduleId.substring(0, index); |
| ModuleFactory moduleFactory = ServerPlugin.findModuleFactory(factoryId); |
| if (moduleFactory == null) |
| return null; |
| |
| String moduleSubId = moduleId.substring(index+1); |
| return moduleFactory.findModule(moduleSubId, null); |
| } |
| |
| /** |
| * Return all the available modules from all factories whose |
| * type matches the given module types. |
| * <p> |
| * This method may trigger bundle loading and is not suitable for |
| * short/UI operations. It also performs a search of all available |
| * modules of the given types, and due to performance reasons should |
| * not be used unless absolutely required. |
| * </p> |
| * |
| * @param moduleTypes an array of module types |
| * @return a possibly empty array of modules |
| */ |
| public static IModule[] getModules(IModuleType[] moduleTypes) { |
| List<IModule> list = new ArrayList<IModule>(); |
| |
| ModuleFactory[] factories = ServerPlugin.getModuleFactories(); |
| if (factories != null) { |
| for (ModuleFactory factory : factories) { |
| if (isSupportedModule(factory.getModuleTypes(), moduleTypes)) { |
| IModule[] modules = factory.getModules(null); |
| if (modules != null) { |
| for (IModule module : modules) |
| list.add(module); |
| } |
| } |
| } |
| } |
| IModule[] modules = new IModule[list.size()]; |
| list.toArray(modules); |
| return modules; |
| } |
| |
| /** |
| * Return all the available modules from all factories whose |
| * type matches the given module type id. |
| * <p> |
| * This method may trigger bundle loading and is not suitable for |
| * short/UI operations. It also performs a search of all available |
| * modules of this type, and due to performance reasons should not |
| * be used unless absolutely required. |
| * </p> |
| * |
| * @param type a module type |
| * @return a possibly empty array of modules |
| */ |
| public static IModule[] getModules(String type) { |
| List<IModule> list = new ArrayList<IModule>(); |
| |
| ModuleFactory[] factories = ServerPlugin.getModuleFactories(); |
| if (factories != null) { |
| for (ModuleFactory factory : factories) { |
| if (isSupportedModule(factory.getModuleTypes(), type, null)) { |
| IModule[] modules = factory.getModules(null); |
| if (modules != null) { |
| for (IModule module : modules) |
| if (type.equals(module.getModuleType().getId())) |
| list.add(module); |
| } |
| } |
| } |
| } |
| IModule[] modules = new IModule[list.size()]; |
| list.toArray(modules); |
| return modules; |
| } |
| |
| /** |
| * Returns <code>true</code> if any of the given moduleTypes have the given |
| * module type id and version id. |
| * |
| * @param moduleTypes an array of module types, may not be null |
| * @param typeId a module type id, or null for any module type |
| * @param versionId a module version, or null for any version |
| * @return <code>true</code> if the module type is supported, and |
| * <code>false</code> otherwise |
| */ |
| public static boolean isSupportedModule(IModuleType[] moduleTypes, String typeId, String versionId) { |
| if (moduleTypes == null) |
| throw new IllegalArgumentException(); |
| |
| if ("".equals(typeId)) |
| typeId = null; |
| if ("".equals(versionId)) |
| versionId = null; |
| |
| if (typeId == null && versionId == null) |
| return true; |
| |
| for (IModuleType moduleType : moduleTypes) { |
| if (isSupportedModule(moduleType, typeId, versionId)) |
| return true; |
| } |
| |
| return false; |
| } |
| |
| private static boolean isSupportedModule(IModuleType[] moduleTypes, IModuleType[] mt) { |
| if (mt != null) { |
| for (IModuleType moduleType : mt) { |
| if (isSupportedModule(moduleTypes, moduleType)) |
| return true; |
| } |
| } |
| return false; |
| } |
| |
| /** |
| * Returns <code>true</code> if any of the given moduleTypes match the given |
| * module type. |
| * |
| * @param moduleTypes an array of modules types, may not be null |
| * @param mt a module type, may not be null |
| * @return <code>true</code> if the module type is supported, and |
| * <code>false</code> otherwise |
| */ |
| public static boolean isSupportedModule(IModuleType[] moduleTypes, IModuleType mt) { |
| if (moduleTypes == null || mt == null) |
| throw new IllegalArgumentException(); |
| |
| for (IModuleType moduleType : moduleTypes) { |
| if (isSupportedModule(moduleType, mt)) |
| return true; |
| } |
| return false; |
| } |
| |
| private static boolean isSupportedModule(IModuleType moduleType, String type, String version) { |
| String type2 = moduleType.getId(); |
| if (ServerPlugin.matches(type, type2)) { |
| String version2 = moduleType.getVersion(); |
| if (ServerPlugin.matches(version, version2)) |
| return true; |
| } |
| return false; |
| } |
| |
| /** |
| * Returns true if the two given module types are compatible. |
| * |
| * @param moduleType a module type, may not be null |
| * @param mt a module type, may not be null |
| * @return <code>true</code> if the module type is supported, and |
| * <code>false</code> otherwise |
| */ |
| public static boolean isSupportedModule(IModuleType moduleType, IModuleType mt) { |
| if (moduleType == null || mt == null) |
| throw new IllegalArgumentException(); |
| |
| if (ServerPlugin.matches(mt.getId(), moduleType.getId()) && |
| ServerPlugin.matches(mt.getVersion(), moduleType.getVersion())) |
| return true; |
| |
| return false; |
| } |
| |
| /** |
| * Adds or removes modules from a server. Will search for the first parent module |
| * of each module and add it to the server instead. This method will handle multiple |
| * modules having the same parent (the parent will only be added once), but may not |
| * handle the case where the same module or parent is being both added and removed. |
| * Entries in the add or remove arrays may not be null. |
| * |
| * @param server a server |
| * @param add an array of modules to add, or <code>null</code> to not add any |
| * @param remove an array of modules to remove, or <code>null</code> to not remove any |
| * @param monitor a progress monitor, or <code>null</code> if progress |
| * reporting and cancellation are not desired |
| * @throws CoreException if anything goes wrong |
| */ |
| public static void modifyModules(IServerWorkingCopy server, IModule[] add, IModule[] remove, IProgressMonitor monitor) throws CoreException { |
| if (server == null) |
| throw new IllegalArgumentException("Server cannot be null"); |
| |
| if (add == null) |
| add = new IModule[0]; |
| if (remove == null) |
| remove = new IModule[0]; |
| |
| for (IModule module : add) { |
| if (module == null) |
| throw new IllegalArgumentException("Cannot add null entries"); |
| } |
| |
| List<IModule> addParentModules = new ArrayList<IModule>(); |
| for (IModule module : add) { |
| boolean found = false; |
| try { |
| IModule[] parents = server.getRootModules(module, monitor); |
| if (parents != null && parents.length > 0) { |
| IModule parent = parents[0]; |
| found = true; |
| if (!addParentModules.contains(parent)) |
| addParentModules.add(parent); |
| } |
| } catch (Exception e) { |
| Trace.trace(Trace.WARNING, "Could not find parent module", e); |
| } |
| |
| if (!found) |
| addParentModules.add(module); |
| } |
| |
| for (IModule module : remove) { |
| if (module == null) |
| throw new IllegalArgumentException("Cannot remove null entries"); |
| } |
| |
| List<IModule> removeParentModules = new ArrayList<IModule>(); |
| for (IModule module : remove) { |
| boolean found = false; |
| try { |
| IModule[] parents = server.getRootModules(module, monitor); |
| if (parents != null && parents.length > 0) { |
| IModule parent = parents[0]; |
| found = true; |
| if (!removeParentModules.contains(parent)) |
| removeParentModules.add(parent); |
| } |
| } catch (Exception e) { |
| Trace.trace(Trace.WARNING, "Could not find parent module 2", e); |
| } |
| |
| if (!found) |
| removeParentModules.add(module); |
| } |
| |
| IModule[] add2 = new IModule[addParentModules.size()]; |
| addParentModules.toArray(add2); |
| IModule[] remove2 = new IModule[removeParentModules.size()]; |
| removeParentModules.toArray(remove2); |
| |
| server.modifyModules(add2, remove2, monitor); |
| } |
| |
| /** |
| * Sets a default name on the given runtime. |
| * |
| * @param runtime a runtime |
| */ |
| public static void setRuntimeDefaultName(IRuntimeWorkingCopy runtime) { |
| setRuntimeDefaultName(runtime, -1); |
| } |
| |
| /** |
| * Sets a default name on the given runtime. |
| * |
| * @param runtime |
| * a runtime |
| * @param suffix |
| * the numbering to start at for the suffix, if suffix is -1, then the no suffix name will be tried first. |
| * @return the suffix it found no name conflicts at and is using as part of |
| * the default name |
| */ |
| public static int setRuntimeDefaultName(IRuntimeWorkingCopy runtime, int suffix) { |
| String typeName = runtime.getRuntimeType().getName(); |
| |
| String name = null; |
| if (suffix == -1) { |
| name = NLS.bind(Messages.defaultRuntimeName, typeName); |
| // Start next suffix from 2 to preserve the original behaviour before this change. |
| suffix = 2; |
| } else { |
| name = NLS.bind(Messages.defaultRuntimeName2, new String[] { typeName, suffix + "" }); |
| } |
| |
| while (ServerPlugin.isNameInUse(runtime.getOriginal(), name)) { |
| suffix++; |
| name = NLS.bind(Messages.defaultRuntimeName2, new String[] { typeName, suffix + "" }); |
| } |
| runtime.setName(name); |
| return suffix; |
| } |
| |
| /** |
| * Sets a default name on the given server. |
| * |
| * @param server a server |
| */ |
| public static void setServerDefaultName(IServerWorkingCopy server) { |
| if (server == null) |
| throw new IllegalArgumentException(); |
| |
| String typeName = server.getServerType().getName(); |
| String host = server.getHost(); |
| |
| // base the name on the runtime if it exists and has been changed from the default |
| IRuntime runtime = server.getRuntime(); |
| if (runtime != null && !(runtime instanceof RuntimeWorkingCopy)) { |
| IRuntimeWorkingCopy wc = runtime.createWorkingCopy(); |
| setRuntimeDefaultName(wc); |
| if (!wc.getName().equals(runtime.getName())) |
| typeName = runtime.getName(); |
| } |
| |
| String name = NLS.bind(Messages.defaultServerName, new String[] {typeName, host}); |
| int i = 2; |
| while (ServerPlugin.isNameInUse(server.getOriginal(), name)) { |
| name = NLS.bind(Messages.defaultServerName2, new String[] {typeName, host, i + ""}); |
| i++; |
| } |
| server.setName(name); |
| } |
| |
| private static boolean isValidFilename(String name) { |
| IStatus status = ResourcesPlugin.getWorkspace().validateName(name, IResource.FILE); |
| if (status != null && !status.isOK()) |
| return false; |
| |
| status = ResourcesPlugin.getWorkspace().validateName(name, IResource.FOLDER); |
| if (status != null && !status.isOK()) |
| return false; |
| |
| return true; |
| } |
| |
| private static String getValidFileName(String name) { |
| if (isValidFilename(name)) |
| return name; |
| |
| // remove invalid characters |
| String[] s = new String[] {".", "\\", "/", "?", ":", "*", "\"", "|", "<", ">"}; |
| int ind = 0; |
| while (ind < s.length) { |
| int index = name.indexOf(s[ind]); |
| while (index >= 0) { |
| name = name.substring(0, index) + name.substring(index+1); |
| index = name.indexOf(s[ind]); |
| } |
| ind++; |
| } |
| return name; |
| } |
| |
| /** |
| * Returns an unused file in the given project. |
| * |
| * @param project a project |
| * @param server a server |
| * @return an unused file within the given project |
| */ |
| public static IFile getUnusedServerFile(IProject project, IServer server) { |
| if (project == null || server == null) |
| throw new IllegalArgumentException(); |
| |
| String typeName = getValidFileName(server.getName()); |
| String name = NLS.bind(Messages.defaultServerName3, typeName)+ "." + Server.FILE_EXTENSION; |
| int i = 2; |
| while (isFileNameInUse(project, name)) { |
| name = NLS.bind(Messages.defaultServerName4, new String[] {typeName, i + ""}) + "." + Server.FILE_EXTENSION; |
| i++; |
| } |
| return project.getFile(name); |
| } |
| |
| /** |
| * Returns true if an element exists with the given name. |
| * |
| * @param project a project |
| * @param name a file or folder name |
| * @return boolean <code>true</code> if the file or folder name is being |
| * used, and <code>false</code> otherwise |
| */ |
| private static boolean isFileNameInUse(IProject project, String name) { |
| if (name == null || project == null) |
| return false; |
| |
| if (project.getFile(name).exists()) |
| return true; |
| if (project.getFolder(name).exists()) |
| return true; |
| |
| return false; |
| } |
| |
| /** |
| * Return a list of all runtime targets that match the given type and version. |
| * If type or version is null, it matches all of that type or version. |
| * |
| * @param type a module type |
| * @param version a module version |
| * @return a possibly-empty array of runtime instances {@link IRuntime} |
| */ |
| public static IRuntime[] getRuntimes(String type, String version) { |
| List<IRuntime> list = new ArrayList<IRuntime>(); |
| IRuntime[] runtimes = ServerCore.getRuntimes(); |
| if (runtimes != null) { |
| for (IRuntime runtime : runtimes) { |
| IRuntimeType runtimeType = runtime.getRuntimeType(); |
| if (runtimeType != null && isSupportedModule(runtimeType.getModuleTypes(), type, version)) { |
| list.add(runtime); |
| } |
| } |
| } |
| |
| IRuntime[] runtimes2 = new IRuntime[list.size()]; |
| list.toArray(runtimes2); |
| return runtimes2; |
| } |
| |
| /** |
| * Return a list of all runtime types that match the given type and version. |
| * If type or version is null, it matches all of that type or version. |
| * |
| * @param type a module type |
| * @param version a module version |
| * @return a possibly-empty array of runtime type instances {@link IRuntimeType} |
| */ |
| public static IRuntimeType[] getRuntimeTypes(String type, String version) { |
| List<IRuntimeType> list = new ArrayList<IRuntimeType>(); |
| IRuntimeType[] runtimeTypes = ServerCore.getRuntimeTypes(); |
| if (runtimeTypes != null) { |
| for (IRuntimeType runtimeType : runtimeTypes) { |
| if (isSupportedModule(runtimeType.getModuleTypes(), type, version)) { |
| list.add(runtimeType); |
| } |
| } |
| } |
| |
| IRuntimeType[] rt = new IRuntimeType[list.size()]; |
| list.toArray(rt); |
| return rt; |
| } |
| |
| /** |
| * Return a list of all runtime types that match the given type, version, |
| * and partial runtime type id. If type, version, or runtimeTypeId is null, |
| * it matches all of that type or version. |
| * |
| * @param type a module type |
| * @param version a module version |
| * @param runtimeTypeId the id of a runtime type |
| * @return a possibly-empty array of runtime type instances {@link IRuntimeType} |
| */ |
| public static IRuntimeType[] getRuntimeTypes(String type, String version, String runtimeTypeId) { |
| List<IRuntimeType> list = new ArrayList<IRuntimeType>(); |
| IRuntimeType[] runtimeTypes = ServerCore.getRuntimeTypes(); |
| if (runtimeTypes != null) { |
| for (IRuntimeType runtimeType : runtimeTypes) { |
| if (isSupportedModule(runtimeType.getModuleTypes(), type, version)) { |
| if (runtimeTypeId == null || runtimeType.getId().startsWith(runtimeTypeId)) |
| list.add(runtimeType); |
| } |
| } |
| } |
| |
| IRuntimeType[] rt = new IRuntimeType[list.size()]; |
| list.toArray(rt); |
| return rt; |
| } |
| |
| /** |
| * Returns a list of all servers that this module is not currently |
| * configured on, but could be added to. If includeErrors is true, this |
| * method return servers where the parent module may throw errors. For |
| * instance, this module may be the wrong spec level. |
| * |
| * @param module a module |
| * @param includeErrors <code>true</code> to include servers that returned |
| * errors when trying to add the module, and <code>false</code> otherwise |
| * @param monitor a progress monitor, or <code>null</code> if progress |
| * reporting and cancellation are not desired |
| * @return a possibly empty array of servers |
| */ |
| public static IServer[] getAvailableServersForModule(IModule module, boolean includeErrors, IProgressMonitor monitor) { |
| if (module == null) |
| return new IServer[0]; |
| |
| // do it the slow way - go through all servers and |
| // see if this deployable is not configured in it |
| // but could be added |
| List<IServer> list = new ArrayList<IServer>(); |
| IServer[] servers = ServerCore.getServers(); |
| if (servers != null) { |
| for (IServer server : servers) { |
| if (!containsModule(server, module, monitor)) { |
| try { |
| IModule[] parents = server.getRootModules(module, monitor); |
| if (parents != null && parents.length > 0) { |
| boolean found = false; |
| int size2 = parents.length; |
| for (int j = 0; !found && j < size2; j++) { |
| IModule parent = parents[j]; |
| IStatus status = server.canModifyModules(new IModule[] { parent }, new IModule[0], monitor); |
| if (status == null || status.isOK()){ |
| list.add(server); |
| found = true; |
| } |
| } |
| } |
| } catch (Exception se) { |
| if (includeErrors) |
| list.add(server); |
| } |
| } |
| } |
| } |
| |
| // make sure that the preferred server is the first one |
| //IServer server = ServerCore.getServerPreferences().getDeployableServerPreference(deployable); |
| //if (server != null && list.contains(server) && list.indexOf(server) != 0) { |
| // list.remove(server); |
| // list.add(0, server); |
| //} |
| |
| IServer[] allServers = new IServer[list.size()]; |
| list.toArray(allServers); |
| return allServers; |
| } |
| |
| /** |
| * Returns a list of all servers that this module is configured on. |
| * |
| * @param module a module |
| * @param monitor a progress monitor, or <code>null</code> if progress |
| * reporting and cancellation are not desired |
| * @return a possibly-empty array of server instances {@link IServer} |
| */ |
| public static IServer[] getServersByModule(IModule module, IProgressMonitor monitor) { |
| if (module == null) |
| return new IServer[0]; |
| |
| // do it the slow way - go through all servers and |
| // see if this module is configured in it |
| List<IServer> list = new ArrayList<IServer>(); |
| IServer[] servers = ServerCore.getServers(); |
| if (servers != null) { |
| for (IServer server : servers) { |
| if (containsModule(server, module, monitor)) |
| list.add(server); |
| } |
| } |
| |
| IServer[] allServers = new IServer[list.size()]; |
| list.toArray(allServers); |
| return allServers; |
| } |
| |
| /** |
| * Returns true if the given server currently contains the given module. |
| * |
| * @param server a server |
| * @param module a module |
| * @param monitor a progress monitor, or <code>null</code> if progress |
| * reporting and cancellation are not desired |
| * @return boolean <code>true</code> if the module is contained on the server, |
| * or <code>false</code> otherwise |
| */ |
| public static boolean containsModule(IServer server, final IModule module, IProgressMonitor monitor) { |
| if (server == null || module == null) |
| throw new IllegalArgumentException("Arguments cannot be null"); |
| |
| Trace.trace(Trace.FINEST, "containsModule() " + server + " " + module); |
| |
| final boolean[] b = new boolean[1]; |
| |
| ((Server)server).visit(new IModuleVisitor() { |
| public boolean visit(IModule[] modules) { |
| int size = modules.length; |
| if (modules[size - 1].equals(module)) { |
| b[0] = true; |
| return false; |
| } |
| return true; |
| } |
| }, null); |
| return b[0]; |
| } |
| |
| /** |
| * Returns the server associated with the given launch configuration. |
| * |
| * @param configuration a launch configuration |
| * @return the server associated with the launch configuration, or |
| * <code>null</code> if no server could be found |
| * @throws CoreException if there is a problem getting the attribute from |
| * the launch configuration |
| */ |
| public static IServer getServer(ILaunchConfiguration configuration) throws CoreException { |
| String serverId = configuration.getAttribute(Server.ATTR_SERVER_ID, (String) null); |
| |
| if (serverId != null) |
| return ServerCore.findServer(serverId); |
| return null; |
| } |
| |
| /** |
| * Validates whether this server can be editted. |
| * |
| * @param context the context (Shell) |
| * @param server the server |
| * @return a status object with code <code>IStatus.OK</code> if the server |
| * can be edited, otherwise a status object indicating what when wrong |
| * with the checkout |
| */ |
| public static IStatus validateEdit(Object context, IServer server) { |
| return ((Server)server).validateEdit(context); |
| } |
| |
| /** |
| * Returns the port that is being used to monitor the given port on the server. |
| * This method can be used whenever creating a 'client' for the server, and allows |
| * the client to seamlessly use a monitored port instead of going directly to the |
| * server. |
| * |
| * <b>Provisional API:</b> This class/interface is part of an interim API that is still under development and expected to |
| * change significantly before reaching stability. It is being made available at this early stage to solicit feedback |
| * from pioneering adopters on the understanding that any code that uses this API will almost certainly be broken |
| * (repeatedly) as the API evolves. |
| * </p> |
| * |
| * @param server a server |
| * @param port a port on the server |
| * @param contentType the content type, e.g. "web" |
| * @return the monitored port, or the original port number if the port is not |
| * currently being monitored |
| */ |
| public static int getMonitoredPort(IServer server, int port, String contentType) { |
| return ServerMonitorManager.getInstance().getMonitoredPort(server, port, contentType); |
| } |
| |
| /** |
| * Returns a scheduling rule to prevent jobs from simultaneously starting, |
| * publishing, or stopping the same server. |
| * |
| * @param server a server |
| * @return a scheduling rule for this server |
| * @since 2.0 |
| * @deprecated the server instance is now a scheduling rule directly |
| */ |
| public static ISchedulingRule getServerSchedulingRule(IServer server) { |
| return server; |
| } |
| } |