|
|||||||||||
PREV CLASS NEXT CLASS | FRAMES NO FRAMES | ||||||||||
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD |
java.lang.Objectorg.eclipse.wst.server.core.model.ServerBehaviourDelegate
public abstract class ServerBehaviourDelegate
A server delegate provides the implementation for various
generic and server-type-specific operations for a specific type of server.
A server delegate is specified by the
class
attribute of a serverTypes
extension.
When the server instance needs to be given a delegate, the delegate class
specified for the server type is instantiated with a 0-argument constructor
and primed with delegate.initialize(((IServerState)server)
,
which it is expected to hang on to. Later, when
delegate.dispose()
is called as the server instance is
being discarded, the delegate is expected to let go of the server instance.
Server delegates may keep state in instance fields, but that state is transient and will not be persisted across workbench sessions.
This abstract class is intended to be extended only by clients
to extend the serverTypes
extension point.
IServer
,
IServerWorkingCopy
Field Summary | |
---|---|
static int |
ADDED
Publish kind constant (value 1) for added resources. |
static int |
CHANGED
Publish kind constant (value 2) for changed resources. |
static int |
NO_CHANGE
Publish kind constant (value 0) for no change. |
static int |
REMOVED
Publish kind constant (value 3) for removed resources. |
Constructor Summary | |
---|---|
ServerBehaviourDelegate()
Delegates must have a public 0-arg constructor. |
Method Summary | |
---|---|
boolean |
canControlModule(IModule[] module)
Returns whether the given module can be restarted. |
IStatus |
canPublish()
Returns whether this server is in a state that it can be published to. |
IStatus |
canRestart(java.lang.String mode)
Returns whether this server is in a state that it can be restarted in the given mode. |
IStatus |
canStart(java.lang.String launchMode)
Returns whether this server is in a state that it can be started in the given mode. |
IStatus |
canStop()
Returns whether this server is in a state that it can be stopped. |
void |
dispose()
Disposes of this server delegate. |
IServer |
getServer()
Returns the server that this server delegate corresponds to. |
void |
handleResourceChange()
Called when resources change within the workspace. |
IStatus |
publish(int kind,
IProgressMonitor monitor)
Publish to the server. |
void |
publish(int kind,
java.util.List<IModule[]> modules,
IProgressMonitor monitor,
IAdaptable info)
Publish to the server. |
void |
restart(java.lang.String launchMode)
Restart this server. |
void |
restartModule(IModule[] module,
IProgressMonitor monitor)
Restarts the given module on the server. |
void |
setupLaunchConfiguration(ILaunchConfigurationWorkingCopy workingCopy,
IProgressMonitor monitor)
Configure the given launch configuration to start this server. |
void |
startModule(IModule[] module,
IProgressMonitor monitor)
Starts the given module on the server. |
abstract void |
stop(boolean force)
Shuts down and stops this server. |
void |
stopModule(IModule[] module,
IProgressMonitor monitor)
Stops the given module on the server. |
Methods inherited from class java.lang.Object |
---|
equals, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait |
Field Detail |
---|
public static final int NO_CHANGE
publishModule(int, int, IModule[], IProgressMonitor)
,
Constant Field Valuespublic static final int ADDED
publishModule(int, int, IModule[], IProgressMonitor)
,
Constant Field Valuespublic static final int CHANGED
publishModule(int, int, IModule[], IProgressMonitor)
,
Constant Field Valuespublic static final int REMOVED
publishModule(int, int, IModule[], IProgressMonitor)
,
Constant Field ValuesConstructor Detail |
---|
public ServerBehaviourDelegate()
Method Detail |
---|
public final IServer getServer()
public void dispose()
This method is called by the server core framework. Clients should never call this method.
Implementations are expected to let go of the delegate's reference to the server, deregister listeners, etc.
public void setupLaunchConfiguration(ILaunchConfigurationWorkingCopy workingCopy, IProgressMonitor monitor) throws CoreException
workingCopy
- a launch configuration working copymonitor
- a progress monitor, or null
if progress
reporting and cancellation are not desired
CoreException
- if there is an error setting up the configurationpublic void restart(java.lang.String launchMode) throws CoreException
launchMode
- the mode to restart in, one of the mode constants
defined by ILaunchManager
CoreException
- if there was a problem restartingpublic boolean canControlModule(IModule[] module)
This call should complete reasonably fast and not require communication with the (potentially remote) server. If communication is required it should be done asynchronously and this method should either fail until that is complete or succeed and handle failure in the xxModule methods.
module
- the module
true
if the given module can be
restarted, and false
otherwisepublic IStatus canStart(java.lang.String launchMode)
This call should complete reasonably fast and not require communication with the (potentially remote) server. If communication is required it should be done asynchronously and this method should either fail until that is complete or succeed and handle failure during start.
This method is called by the server core framework,
in response to a call to IServer.canStart()
.
The framework has already filtered out obviously invalid situations,
such as starting a server that is already running.
Clients should never call this method directly.
launchMode
- a mode in which a server can be launched,
one of the mode constants defined by
org.eclipse.debug.core.ILaunchManager
IStatus.OK
if the server can
be started, otherwise a status object indicating why it can'tpublic IStatus canRestart(java.lang.String mode)
This call should complete reasonably fast and not require communication with the (potentially remote) server. If communication is required it should be done asynchronously and this method should either fail until that is complete or succeed and handle failure during restart.
This method is called by the server core framework,
in response to a call to IServer.canRestart()
.
The framework has already filtered out obviously invalid situations,
such as restarting a stopped server.
Clients should never call this method directly.
mode
- a mode in which a server can be launched,
one of the mode constants defined by
org.eclipse.debug.core.ILaunchManager
IStatus.OK
if the server can
be restarted, otherwise a status object indicating why it can'tpublic IStatus canStop()
This call should complete reasonably fast and not require communication with the (potentially remote) server. If communication is required it should be done asynchronously and this method should either fail until that is complete or succeed and handle failure during stop.
This method is called by the server core framework,
in response to a call to IServer.canStop()
.
The framework has already filtered out obviously invalid situations,
such as stopping a server that is already stopped.
Clients should never call this method directly.
IStatus.OK
if the server can
be stopped, otherwise a status object indicating why it can'tpublic IStatus canPublish()
This call should complete reasonably fast and not require communication with the (potentially remote) server. If communication is required it should be done asynchronously and this method should either fail until that is complete or succeed and handle failure during publish.
This method is called by the server core framework,
in response to a call to IServer.canPublish()
.
The framework has already filtered out obviously invalid situations,
such as publishing to a server in the wrong mode.
Clients should never call this method directly.
IStatus.OK
if the server can
be published to, otherwise a status object indicating what is wrongpublic void startModule(IModule[] module, IProgressMonitor monitor) throws CoreException
IServer.startModule(IModule[], IServer.IOperationListener)
for further details.
The implementation should update the module sync state and fire an event for the module.
This method will throw an exception if the module does not exist on the server.
[issue: Since this method is asynchronous, is there any need for the progress monitor?]
module
- the module to be startedmonitor
- a progress monitor, or null
if progress
reporting and cancellation are not desired
CoreException
- if an error occurs while trying to restart the modulepublic void stopModule(IModule[] module, IProgressMonitor monitor) throws CoreException
IServer.stopModule(IModule[], IServer.IOperationListener)
for further details.
The implementation should update the module sync state and fire an event for the module.
This method will throw an exception if the module does not exist on the server.
[issue: Since this method is asynchronous, is there any need for the progress monitor?]
module
- the module to be stoppedmonitor
- a progress monitor, or null
if progress
reporting and cancellation are not desired
CoreException
- if an error occurs while trying to restart the modulepublic void restartModule(IModule[] module, IProgressMonitor monitor) throws CoreException
IServer.restartModule(IModule[], IServer.IOperationListener)
for further details.
The implementation should update the module sync state and fire an event for the module.
This method will throw an exception if the module does not exist on the server.
[issue: Since this method is asynchronous, is there any need for the progress monitor?]
module
- the module to be stoppedmonitor
- a progress monitor, or null
if progress
reporting and cancellation are not desired
CoreException
- if an error occurs while trying to restart the modulepublic abstract void stop(boolean force)
If force is false
, it will attempt to stop the server
normally/gracefully. If force is true
, then the server
process will be terminated any way that it can.
[issue: There is no way to communicate failure to the client. Given that this operation can go awry, there probably should be a mechanism that allows failing async operations to be diagnosed.]
force
- true
to kill the server, or false
to stop normallypublic void publish(int kind, java.util.List<IModule[]> modules, IProgressMonitor monitor, IAdaptable info) throws CoreException
kind
- the publish kindmodules
- monitor
- a progress monitor, or null
if progress
reporting and cancellation are not desiredinfo
-
CoreException
public IStatus publish(int kind, IProgressMonitor monitor)
kind
- the publish kindmonitor
- a progress monitor, or null
if progress
reporting and cancellation are not desired
public void handleResourceChange()
|
|||||||||||
PREV CLASS NEXT CLASS | FRAMES NO FRAMES | ||||||||||
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD |