1 /* 2 * $Id: UMOManager.java 7976 2007-08-21 14:26:13Z dirk.olmes $ 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 CPAL v1.0 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.manager; 12 13 import org.mule.impl.internal.notifications.NotificationException; 14 import org.mule.umo.UMOException; 15 import org.mule.umo.UMOInterceptorStack; 16 import org.mule.umo.endpoint.UMOEndpoint; 17 import org.mule.umo.lifecycle.InitialisationException; 18 import org.mule.umo.lifecycle.Lifecycle; 19 import org.mule.umo.model.UMOModel; 20 import org.mule.umo.provider.UMOConnector; 21 import org.mule.umo.security.UMOSecurityManager; 22 import org.mule.umo.transformer.UMOTransformer; 23 import org.mule.util.queue.QueueManager; 24 25 import java.util.Map; 26 27 import javax.transaction.TransactionManager; 28 29 /** 30 * <code>UMOManager</code> maintains and provides services for a UMO server 31 * instance. 32 * 33 */ 34 public interface UMOManager extends Lifecycle 35 { 36 /** 37 * Getter for the envionment parameters declared in the mule-config.xml 38 * 39 * @param key the propery name 40 * @return the property value 41 */ 42 Object getProperty(Object key); 43 44 /** 45 * @param logicalName the name of the endpoint to retrieve 46 * @return the endpoint instnace if it exists 47 */ 48 UMOConnector lookupConnector(String logicalName); 49 50 /** 51 * @param logicalName the logical mapping name for an endpointUri i.e. rather 52 * than specifing an endpointUri to be someone@my.com you can supply a 53 * more descriptive name such as <i>The System Administrator</i> 54 * @param defaultName 55 * @return the actual endpointUri value or null if it is not found 56 * @deprecated endpoint-identifiers have been deprecated in favor of global-endpoints 57 */ 58 String lookupEndpointIdentifier(String logicalName, String defaultName); 59 60 /** 61 * Getter for a global endpoint. Any endpoints returned from this method can be 62 * modified, as they are clones of the registered endpoints. 63 * 64 * @param logicalName the name of the endpoint 65 * @return the <code>UMOEndpoint</code> or null if it doesn't exist 66 */ 67 UMOEndpoint lookupEndpoint(String logicalName); 68 69 /** 70 * Getter method for a Transformer. 71 * 72 * @param name the name of the transformer 73 * @return the Transformer instance if found, otherwise null 74 */ 75 UMOTransformer lookupTransformer(String name); 76 77 /** 78 * Registers a <code>UMOConnector</code> with the <code>MuleManager</code>. 79 * 80 * @param connector the <code>UMOConnector</code> to register 81 */ 82 void registerConnector(UMOConnector connector) throws UMOException; 83 84 /** 85 * UnRegisters a <code>UMOConnector</code> with the <code>MuleManager</code>. 86 * 87 * @param connectorName the name of the <code>UMOConnector</code> to unregister 88 */ 89 void unregisterConnector(String connectorName) throws UMOException; 90 91 /** 92 * Registers an endpointUri with a logical name 93 * 94 * @param logicalName the name of the endpointUri 95 * @param endpoint the physical endpointUri value 96 * @deprecated endpoint-identifiers have been deprecated in favor of global-endpoints 97 */ 98 void registerEndpointIdentifier(String logicalName, String endpoint) throws InitialisationException; 99 100 /** 101 * unregisters an endpointUri with a logical name 102 * 103 * @param logicalName the name of the endpointUri 104 * @deprecated endpoint-identifiers have been deprecated in favor of global-endpoints 105 */ 106 void unregisterEndpointIdentifier(String logicalName); 107 108 /** 109 * Registers a shared/global endpoint with the <code>MuleManager</code>. 110 * 111 * @param endpoint the <code>UMOEndpoint</code> to register. 112 */ 113 void registerEndpoint(UMOEndpoint endpoint) throws InitialisationException; 114 115 /** 116 * unregisters a shared/global endpoint with the <code>MuleManager</code>. 117 * 118 * @param endpointName the <code>UMOEndpoint</code> name to unregister. 119 */ 120 void unregisterEndpoint(String endpointName); 121 122 /** 123 * Registers a transformer with the <code>MuleManager</code>. 124 * 125 * @param transformer the <code>UMOTransformer</code> to register. 126 */ 127 void registerTransformer(UMOTransformer transformer) throws InitialisationException; 128 129 /** 130 * UnRegisters a transformer with the <code>MuleManager</code>. 131 * 132 * @param transformerName the <code>UMOTransformer</code> name to register. 133 */ 134 void unregisterTransformer(String transformerName); 135 136 /** 137 * Sets an Mule environment parameter in the <code>MuleManager</code>. 138 * 139 * @param key the parameter name 140 * @param value the parameter value 141 */ 142 void setProperty(Object key, Object value); 143 144 /** 145 * Sets the Jta Transaction Manager to use with this Mule server instance 146 * 147 * @param manager the manager to use 148 * @throws Exception 149 */ 150 void setTransactionManager(TransactionManager manager) throws Exception; 151 152 /** 153 * Returns the Jta transaction manager used by this Mule server instance. or null 154 * if a transaction manager has not been set 155 * 156 * @return the Jta transaction manager used by this Mule server instance. or null 157 * if a transaction manager has not been set 158 */ 159 TransactionManager getTransactionManager(); 160 161 /** 162 * The model used for managing components for this server 163 * 164 * @return The model used for managing components for this server 165 */ 166 UMOModel lookupModel(String name); 167 168 void registerModel(UMOModel model) throws UMOException; 169 170 void unregisterModel(String name); 171 172 /** 173 * The model used for managing components for this server 174 * 175 * @return The models set on this manager instance 176 */ 177 Map getModels(); 178 179 /** 180 * Gets all properties associated with the UMOManager 181 * 182 * @return a map of properties on the Manager 183 */ 184 Map getProperties(); 185 186 /** 187 * Gets an unmodifiable collection of Connectors registered with the UMOManager 188 * 189 * @return All connectors registered on the Manager 190 * @see UMOConnector 191 */ 192 Map getConnectors(); 193 194 /** 195 * Gets an unmodifiable collection of endpoints registered with the UMOManager 196 * 197 * @return All endpoints registered on the Manager 198 * @deprecated endpoint-identifiers have been deprecated in favor of global-endpoints 199 */ 200 Map getEndpointIdentifiers(); 201 202 /** 203 * Gets an unmodifiable collection of endpoints registered with the UMOManager 204 * 205 * @return All endpoints registered on the Manager 206 * @see org.mule.umo.endpoint.UMOEndpoint 207 */ 208 Map getEndpoints(); 209 210 /** 211 * Gets an unmodifiable collection of transformers registered with the UMOManager 212 * 213 * @return All transformers registered on the Manager 214 * @see UMOTransformer 215 */ 216 Map getTransformers(); 217 218 /** 219 * registers a interceptor stack list that can be referenced by other components 220 * 221 * @param name the referenceable name for this stack 222 * @param stack a List of interceptors 223 * @see org.mule.umo.UMOInterceptor 224 */ 225 void registerInterceptorStack(String name, UMOInterceptorStack stack); 226 227 /** 228 * Retrieves a configured interceptor stack. 229 * 230 * @param name the name of the stack 231 * @return the interceptor stack requested or null if there wasn't one configured 232 * for the given name 233 */ 234 UMOInterceptorStack lookupInterceptorStack(String name); 235 236 /** 237 * Determines if the server has been started 238 * 239 * @return true if the server has been started 240 */ 241 boolean isStarted(); 242 243 /** 244 * Determines if the server has been initialised 245 * 246 * @return true if the server has been initialised 247 */ 248 boolean isInitialised(); 249 250 /** 251 * Returns the long date when the server was started 252 * 253 * @return the long date when the server was started 254 */ 255 long getStartDate(); 256 257 /** 258 * Will register an agent object on this model. Agents can be server plugins such 259 * as Jms support 260 * 261 * @param agent 262 */ 263 void registerAgent(UMOAgent agent) throws UMOException; 264 265 /** 266 * Will find a registered agent using its name, which is unique for all 267 * registered agents 268 * 269 * @param name the name of the Agent to find 270 * @return the Agent or null if there is not agent registered with the given name 271 */ 272 UMOAgent lookupAgent(String name); 273 274 /** 275 * Removes and destroys a registered agent 276 * 277 * @param name the agent name 278 * @return the destroyed agent or null if the agent doesn't exist 279 */ 280 UMOAgent unregisterAgent(String name) throws UMOException; 281 282 /** 283 * Registers an intenal server event listener. The listener will be notified when 284 * a particular event happens within the server. Typically this is not an event 285 * in the same sense as an UMOEvent (although there is nothing stopping the 286 * implementation of this class triggering listeners when a UMOEvent is 287 * received). The types of notifications fired is entirely defined by the 288 * implementation of this class 289 * 290 * @param l the listener to register 291 */ 292 void registerListener(UMOServerNotificationListener l) throws NotificationException; 293 294 /** 295 * Registers an intenal server event listener. The listener will be notified when 296 * a particular event happens within the server. Typically this is not an event 297 * in the same sense as an UMOEvent (although there is nothing stopping the 298 * implementation of this class triggering listeners when a UMOEvent is 299 * received). The types of notifications fired is entirely defined by the 300 * implementation of this class 301 * 302 * @param l the listener to register 303 * @param resourceIdentifier a particular resource name for the given type of 304 * listener For example, the resourceName could be the name of a 305 * component if the listener was a ComponentNotificationListener 306 */ 307 void registerListener(UMOServerNotificationListener l, String resourceIdentifier) 308 throws NotificationException; 309 310 /** 311 * Unregisters a previously registered listener. If the listener has not already 312 * been registered, this method should return without exception 313 * 314 * @param l the listener to unregister 315 */ 316 void unregisterListener(UMOServerNotificationListener l); 317 318 /** 319 * Fires a server notification to all regiistered listeners 320 * 321 * @param notification the notification to fire 322 */ 323 void fireNotification(UMOServerNotification notification); 324 325 /** 326 * associates a Dependency Injector container with Mule. This can be used to 327 * integrate container managed resources with Mule resources 328 * 329 * @param context a Container context to use. 330 */ 331 void setContainerContext(UMOContainerContext context) throws UMOException; 332 333 /** 334 * associates a Dependency Injector container with Mule. This can be used to 335 * integrate container managed resources with Mule resources 336 * 337 * @return the container associated with the Manager 338 */ 339 UMOContainerContext getContainerContext(); 340 341 /** 342 * Sets the unique Id for this Manager instance. this id can be used to assign an 343 * identy to the manager so it can be identified in a network of Mule nodes 344 * 345 * @param id the unique Id for this manager in the network 346 */ 347 void setId(String id); 348 349 /** 350 * Gets the unique Id for this Manager instance. this id can be used to assign an 351 * identy to the manager so it can be identified in a network of Mule nodes 352 * 353 * @return the unique Id for this manager in the network 354 */ 355 String getId(); 356 357 /** 358 * Sets the security manager used by this Mule instance to authenticate and 359 * authorise incoming and outgoing event traffic and service invocations 360 * 361 * @param securityManager the security manager used by this Mule instance to 362 * authenticate and authorise incoming and outgoing event traffic and 363 * service invocations 364 */ 365 void setSecurityManager(UMOSecurityManager securityManager) throws InitialisationException; 366 367 /** 368 * Gets the security manager used by this Mule instance to authenticate and 369 * authorise incoming and outgoing event traffic and service invocations 370 * 371 * @return he security manager used by this Mule instance to authenticate and 372 * authorise incoming and outgoing event traffic and service invocations 373 */ 374 UMOSecurityManager getSecurityManager(); 375 376 /** 377 * Obtains a workManager instance that can be used to schedule work in a thread 378 * pool. This will be used primarially by UMOAgents wanting to schedule work. 379 * This work Manager must <b>never</b> be used by provider implementations as 380 * they have their own workManager accible on the connector. 381 * 382 * @return a workManager instance used by the current MuleManager 383 */ 384 UMOWorkManager getWorkManager(); 385 386 /** 387 * Sets a workManager instance that can be used to schedule work in a thread 388 * pool. This will be used primarially by UMOAgents wanting to schedule work. 389 * This work Manager must <b>never</b> be used by provider implementations as 390 * they have their own workManager accible on the connector. 391 * 392 * @param workManager the workManager instance used by the current MuleManager 393 */ 394 void setWorkManager(UMOWorkManager workManager); 395 396 /** 397 * Sets the queue manager used by mule for queuing events. This is used by both 398 * components and vm provider. 399 * 400 * @param queueManager 401 */ 402 void setQueueManager(QueueManager queueManager); 403 404 /** 405 * Gets the queue manager used by mule for queuing events. This is used by both 406 * components and vm provider. 407 * 408 * @return 409 */ 410 QueueManager getQueueManager(); 411 }