KickJava   Java API By Example, From Geeks To Geeks.

Java > Open Source Codes > org > mule > umo > model > UMOModel


1 /*
2  * $Id: UMOModel.java 3798 2006-11-04 04:07:14Z aperepel $
3  * --------------------------------------------------------------------------------------
4  * Copyright (c) MuleSource, Inc. All rights reserved. http://www.mulesource.com
5  *
6  * The software in this package is published under the terms of the MuleSource MPL
7  * license, a copy of which has been included with this distribution in the
8  * LICENSE.txt file.
9  */

10
11 package org.mule.umo.model;
12
13 import org.mule.umo.UMOComponent;
14 import org.mule.umo.UMODescriptor;
15 import org.mule.umo.UMOException;
16 import org.mule.umo.UMOSession;
17 import org.mule.umo.lifecycle.Initialisable;
18 import org.mule.umo.lifecycle.Lifecycle;
19 import org.mule.umo.lifecycle.UMOLifecycleAdapterFactory;
20
21 import java.beans.ExceptionListener JavaDoc;
22 import java.util.Iterator JavaDoc;
23 import java.util.List JavaDoc;
24
25 /**
26  * The <code>UMOModel</code> encapsulates and manages the runtime behaviour of a
27  * Mule Server instance. It is responsible for maintaining the UMOs instances and
28  * their configuration.
29  *
30  * @author <a HREF="mailto:ross.mason@symphonysoft.com">Ross Mason</a>
31  * @version $Revision: 3798 $
32  */

33 public interface UMOModel extends Lifecycle, Initialisable
34 {
35
36     /**
37      * Sets the model's name. It is poosible to configure more than one model in a
38      * config file. The name can then be used to reference the Model use when
39      * starting the server
40      *
41      * @param name the model's name
42      */

43     void setName(String JavaDoc name);
44
45     /**
46      * The model's name. It is poosible to configure more than one model in a config
47      * file. The name can then be used to reference the Model use when starting the
48      * server
49      *
50      * @return the model's name
51      */

52     String JavaDoc getName();
53
54     /**
55      * Returns the model type name. This is a friendly identifier that is used to
56      * look up the SPI class for the model
57      *
58      * @return the model type
59      */

60     String JavaDoc getType();
61
62     /**
63      * The entry point resolver is used to determine the method to be called on a
64      * component when an event is received for it.
65      *
66      * @return Returns the entryPointResolver.
67      */

68     UMOEntryPointResolver getEntryPointResolver();
69
70     /**
71      * This will be used to build entry points on the components registered with the
72      * model.
73      *
74      * @param entryPointResolver The entryPointResolver to set. This will be used to
75      * build entry points on the components registered with the model.
76      */

77     void setEntryPointResolver(UMOEntryPointResolver entryPointResolver);
78
79     /**
80      * Registers a <code>UMODescriptor</code> with the <code>MuleManager</code>.
81      * The manager will take care of creating the Mule UMO and, it's component and
82      * proxies.
83      *
84      * @param descriptor the <code>UMODescriptor</code> to register
85      */

86     UMOComponent registerComponent(UMODescriptor descriptor) throws UMOException;
87
88     /**
89      * Unregisters a component From the model
90      *
91      * @param descriptor the descriptor of the componnt to remove
92      * @throws UMOException if the component is not registered or it failed to be
93      * disposing or the descriptor is null
94      */

95     void unregisterComponent(UMODescriptor descriptor) throws UMOException;
96
97     /**
98      * Determines if a UMO component descriptor by the given name is regestered with
99      * the model
100      *
101      * @param name the name of the UMO
102      * @return true if the UMO's descriptor has benn registered with the model
103      * @see UMODescriptor
104      */

105     boolean isComponentRegistered(String JavaDoc name);
106
107     /**
108      * The lifecycle adapter is used by the model to translate Mule lifecycle event
109      * to events that UMO components registered with the model understand. The
110      * <code>UMOLifecycleAdapterFactory</code> is used by the model to instanciate
111      * LifecycleAdapters.
112      *
113      * @return Returns the lifecycleAdapterFactory used by this Model.
114      * @see UMOLifecycleAdapterFactory
115      * @see org.mule.umo.lifecycle.UMOLifecycleAdapter
116      */

117     UMOLifecycleAdapterFactory getLifecycleAdapterFactory();
118
119     /**
120      * Sets the lifecycleAdapterFactory on the model.
121      *
122      * @param lifecycleAdapterFactory The lifecycleAdapterFactory to set on this
123      * model.
124      * @see UMOLifecycleAdapterFactory
125      * @see org.mule.umo.lifecycle.UMOLifecycleAdapter
126      */

127     void setLifecycleAdapterFactory(UMOLifecycleAdapterFactory lifecycleAdapterFactory);
128
129     /**
130      * Returns the Component for the given Mule name.
131      *
132      * @param muleName the Name of the Mule Component to obtain a session for
133      * @return a UMOSession for the given name or null if the component is not
134      * registered
135      */

136     UMOSession getComponentSession(String JavaDoc muleName);
137
138     /**
139      * A convenience method to set a list of components on the model. This method
140      * will most likely be used when the model is being constructed from an IoC
141      * container
142      *
143      * @param descriptors
144      * @throws UMOException
145      */

146     void setComponents(List JavaDoc descriptors) throws UMOException;
147
148     /**
149      * The exception strategy to use by components managed by the model. The
150      * exception strategy is used when an exception occurs while processing the
151      * current event for a component. A component can define it's own exception
152      * strategy, but if it doesn't this implmentation will be used.
153      *
154      * @return the default exception strategy for this model.
155      * @see ExceptionListener
156      */

157     ExceptionListener JavaDoc getExceptionListener();
158
159     /**
160      * The exception strategy to use by components managed by the model. The
161      * exception strategy is used when an exception occurs while processing the
162      * current event for a component. A component can define it's own exception
163      * strategy, but if it doesn't this implmentation will be used.
164      *
165      * @param listener the default exception strategy for this model.
166      * @see ExceptionListener
167      */

168     void setExceptionListener(ExceptionListener JavaDoc listener);
169
170     /**
171      * Returns a descriptor for the given component name
172      *
173      * @param name the name of the component
174      * @return a descriptor for the given component name or null if there is no
175      * component registered by that name
176      * @see UMODescriptor
177      */

178     UMODescriptor getDescriptor(String JavaDoc name);
179
180     /**
181      * Returns the UMOComponent object for the given component name
182      *
183      * @param name the name of the component
184      * @return the UMOComponent object for the given component name or null if there
185      * is no component registered by that name
186      * @see UMOComponent
187      */

188     UMOComponent getComponent(String JavaDoc name);
189
190     /**
191      * Stops a single Mule Component. This can be useful when stopping and starting
192      * some Mule UMOs while letting others continue. When a component is stopped all
193      * listeners for that component are unregistered.
194      *
195      * @param name the name of the Mule UMO to stop
196      * @throws UMOException if the MuleUMO is not registered or the component failed
197      * to stop
198      */

199     void stopComponent(String JavaDoc name) throws UMOException;
200
201     /**
202      * Starts a single Mule Component. This can be useful when stopping and starting
203      * some Mule UMOs while letting others continue.
204      *
205      * @param name the name of the Mule UMO to start
206      * @throws UMOException if the MuleUMO is not registered or the component failed
207      * to start
208      */

209     void startComponent(String JavaDoc name) throws UMOException;
210
211     /**
212      * Pauses event processing for a single Mule Component. Unlike stopComponent(), a
213      * paused component will still consume messages from the underlying transport,
214      * but those messages will be queued until the component is resumed. In order to
215      * persist these queued messages you can set the 'recoverableMode' property on
216      * the Muleconfiguration to true. this causes all internal queues to store their
217      * state.
218      *
219      * @param name the name of the Mule UMO to stop
220      * @throws UMOException if the MuleUMO is not registered or the component failed
221      * to pause.
222      * @see org.mule.config.MuleConfiguration
223      */

224     void pauseComponent(String JavaDoc name) throws UMOException;
225
226     /**
227      * Resumes a single Mule Component that has been paused. If the component is not
228      * paused nothing is executed.
229      *
230      * @param name the name of the Mule UMO to resume
231      * @throws UMOException if the MuleUMO is not registered or the component failed
232      * to resume
233      */

234     void resumeComponent(String JavaDoc name) throws UMOException;
235
236     /**
237      * Gets an iterator of all component names registered in the model
238      *
239      * @return an iterator of all component names
240      */

241     Iterator JavaDoc getComponentNames();
242 }
243
Popular Tags