1 /* 2 * $Id: DefaultMuleEventContext.java 19191 2010-08-25 21:05:23Z tcarlson $ 3 * -------------------------------------------------------------------------------------- 4 * Copyright (c) MuleSoft, Inc. All rights reserved. http://www.mulesoft.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; 12 13 import org.mule.api.FutureMessageResult; 14 import org.mule.api.MessagingException; 15 import org.mule.api.MuleContext; 16 import org.mule.api.MuleEvent; 17 import org.mule.api.MuleEventContext; 18 import org.mule.api.MuleException; 19 import org.mule.api.MuleMessage; 20 import org.mule.api.MuleSession; 21 import org.mule.api.client.LocalMuleClient; 22 import org.mule.api.config.MuleProperties; 23 import org.mule.api.construct.FlowConstruct; 24 import org.mule.api.endpoint.EndpointBuilder; 25 import org.mule.api.endpoint.EndpointNotFoundException; 26 import org.mule.api.endpoint.EndpointURI; 27 import org.mule.api.endpoint.InboundEndpoint; 28 import org.mule.api.endpoint.OutboundEndpoint; 29 import org.mule.api.processor.MessageProcessor; 30 import org.mule.api.service.Service; 31 import org.mule.api.transaction.Transaction; 32 import org.mule.api.transaction.TransactionException; 33 import org.mule.api.transformer.DataType; 34 import org.mule.api.transformer.TransformerException; 35 import org.mule.config.i18n.CoreMessages; 36 import org.mule.endpoint.EndpointURIEndpointBuilder; 37 import org.mule.endpoint.URIBuilder; 38 import org.mule.transaction.TransactionCoordination; 39 import org.mule.transformer.types.DataTypeFactory; 40 41 import java.io.OutputStream; 42 43 import edu.emory.mathcs.backport.java.util.concurrent.Callable; 44 45 import org.apache.commons.logging.Log; 46 import org.apache.commons.logging.LogFactory; 47 48 /** 49 * <code>DefaultMuleEventContext</code> is the context object for the current 50 * request. Using the context, developers can send/dispatch/receive events 51 * programmatically as well as manage transactions. 52 */ 53 public class DefaultMuleEventContext implements MuleEventContext 54 { 55 /** 56 * logger used by this class 57 */ 58 protected static final Log logger = LogFactory.getLog(DefaultMuleEventContext.class); 59 60 private final MuleEvent event; 61 private final MuleSession session; 62 private final MuleContext muleContext; 63 private final LocalMuleClient clientInterface; 64 65 public DefaultMuleEventContext(MuleEvent event) 66 { 67 this.event = event; 68 this.session = event.getSession(); 69 this.muleContext = event.getMuleContext(); 70 this.clientInterface = muleContext.getClient(); 71 } 72 73 /** 74 * Returns the message payload for this event 75 * 76 * @return the message payload for this event 77 */ 78 public MuleMessage getMessage() 79 { 80 return event.getMessage(); 81 } 82 83 /** 84 * Reterns the conents of the message as a byte array. 85 * 86 * @return the conents of the message as a byte array 87 * @throws org.mule.api.MuleException if the message cannot be converted into an 88 * array of bytes 89 */ 90 public byte[] getMessageAsBytes() throws MuleException 91 { 92 return event.getMessageAsBytes(); 93 } 94 95 /** 96 * Returns the message transformed into its recognised or expected format. The 97 * transformer used is the one configured on the endpoint through which this 98 * event was received. 99 * 100 * @param dataType The dataType required for the return object. This param 101 * just provides a convienient way to manage type casting of 102 * transformed objects 103 * @return the message transformed into it's recognised or expected format. 104 * @throws org.mule.api.transformer.TransformerException if a failure occurs or 105 * if the return type is not the same as the expected type in the 106 * transformer 107 * @see org.mule.api.transformer.Transformer 108 */ 109 public Object transformMessage(DataType dataType) throws TransformerException 110 { 111 return event.transformMessage(dataType); 112 } 113 114 /** 115 * Returns the message transformed into its recognised or expected format. The 116 * transformer used is the one configured on the endpoint through which this 117 * event was received. 118 * 119 * @param expectedType The class type required for the return object. This param 120 * just provides a convienient way to manage type casting of 121 * transformed objects 122 * @return the message transformed into it's recognised or expected format. 123 * @throws org.mule.api.transformer.TransformerException if a failure occurs or 124 * if the return type is not the same as the expected type in the 125 * transformer 126 * @see org.mule.api.transformer.Transformer 127 */ 128 public Object transformMessage(Class expectedType) throws TransformerException 129 { 130 return event.transformMessage(DataTypeFactory.create(expectedType)); 131 } 132 133 /** 134 * Returns the message transformed into it's recognised or expected format and 135 * then into an array of bytes. The transformer used is the one configured on the 136 * endpoint through which this event was received. 137 * 138 * @return the message transformed into it's recognised or expected format as an 139 * array of bytes. 140 * @throws org.mule.api.transformer.TransformerException if a failure occurs in 141 * the transformer 142 * @see org.mule.api.transformer.Transformer 143 * @deprecated use {@link #transformMessage(org.mule.api.transformer.DataType)} instead 144 */ 145 @Deprecated 146 public byte[] transformMessageToBytes() throws TransformerException 147 { 148 return event.transformMessage(DataType.BYTE_ARRAY_DATA_TYPE); 149 } 150 151 /** 152 * Returns the message contents as a string 153 * 154 * @return the message contents as a string 155 * @throws org.mule.api.MuleException if the message cannot be converted into a 156 * string 157 */ 158 public String getMessageAsString(String encoding) throws MuleException 159 { 160 return event.getMessageAsString(encoding); 161 } 162 163 /** 164 * Returns the message transformed into it's recognised or expected format and 165 * then into a String. The transformer used is the one configured on the endpoint 166 * through which this event was received. This method will use the default 167 * encoding on the event 168 * 169 * @return the message transformed into it's recognised or expected format as a 170 * Strings. 171 * @throws org.mule.api.transformer.TransformerException if a failure occurs in 172 * the transformer 173 * @see org.mule.api.transformer.Transformer 174 */ 175 public String transformMessageToString() throws TransformerException 176 { 177 return event.transformMessageToString(); 178 } 179 180 /** 181 * Returns the message contents as a string This method will use the default 182 * encoding on the event 183 * 184 * @return the message contents as a string 185 * @throws org.mule.api.MuleException if the message cannot be converted into a 186 * string 187 */ 188 public String getMessageAsString() throws MuleException 189 { 190 return event.getMessageAsString(); 191 } 192 193 /** 194 * Returns the current transaction (if any) for the session 195 * 196 * @return the current transaction for the session or null if there is no 197 * transaction in progress 198 */ 199 public Transaction getCurrentTransaction() 200 { 201 return TransactionCoordination.getInstance().getTransaction(); 202 } 203 204 public void markTransactionForRollback() throws TransactionException 205 { 206 if (getCurrentTransaction() != null) 207 { 208 getCurrentTransaction().setRollbackOnly(); 209 } 210 } 211 212 /** 213 * This will send an event via the configured outbound router on the service 214 * 215 * @param message the message to send 216 * @return the result of the send if any 217 * @throws org.mule.api.MuleException if there is no outbound endpoint configured 218 * on the service or the events fails during dispatch 219 */ 220 public MuleMessage sendEvent(Object message) throws MuleException 221 { 222 return sendEvent(new DefaultMuleMessage(message, event.getMessage(), event.getMuleContext())); 223 } 224 225 /** 226 * Depending on the session state this methods either Passes an event 227 * synchronously to the next available Mule component in the pool or via the 228 * endpoint configured for the event 229 * 230 * @param message the event message payload to send 231 * @param endpoint The endpoint to disptch the event through. 232 * @return the return Message from the call or null if there was no result 233 * @throws org.mule.api.MuleException if the event fails to be processed by the 234 * service or the transport for the endpoint 235 */ 236 public MuleMessage sendEvent(MuleMessage message, OutboundEndpoint endpoint) throws MuleException 237 { 238 return clientInterface.process(endpoint, message); 239 } 240 241 /** 242 * Depending on the session state this methods either Passes an event 243 * synchronously to the next available Mule component in the pool or via the 244 * endpoint configured for the event 245 * 246 * @param message the message payload to send 247 * @return the return Message from the call or null if there was no result 248 * @throws org.mule.api.MuleException if the event fails to be processed by the 249 * service or the transport for the endpoint 250 */ 251 public MuleMessage sendEvent(MuleMessage message) throws MuleException 252 { 253 if (event.getEndpoint() instanceof OutboundEndpoint) 254 { 255 return clientInterface.process((OutboundEndpoint) event.getEndpoint(), message); 256 } 257 else if (session.getFlowConstruct() instanceof Service) 258 { 259 Service service = (Service) session.getFlowConstruct(); 260 DefaultMuleEvent eventToSend = new DefaultMuleEvent(message, event.getEndpoint(), session); 261 MuleEvent event = service.sendEvent(eventToSend); 262 return event == null ? null : event.getMessage(); 263 } 264 else 265 { 266 throw new MessagingException( 267 CoreMessages.createStaticMessage("Current event has 'inbound' endpoint and FlowConstuct is not a 'Service', MuleEventContext cannot this message"), 268 event); 269 } 270 } 271 272 /** 273 * Depending on the session state this methods either Passes an event 274 * synchronously to the next available Mule component in the pool or via the 275 * endpointUri configured for the event 276 * 277 * @param message the event message payload to send 278 * @param endpointUri The endpointUri to disptch the event through 279 * @return the return Message from the call or null if there was no result 280 * @throws org.mule.api.MuleException if the event fails to be processed by the 281 * service or the transport for the endpointUri 282 */ 283 public MuleMessage sendEvent(MuleMessage message, EndpointURI endpointUri) throws MuleException 284 { 285 EndpointBuilder builder = null; 286 if (endpointUri.getEndpointName() != null) 287 { 288 builder = muleContext.getRegistry().lookupEndpointBuilder(endpointUri.getEndpointName()); 289 } 290 if (builder == null) 291 { 292 builder = new EndpointURIEndpointBuilder(new URIBuilder(endpointUri)); 293 } 294 295 builder.setExchangePattern(MessageExchangePattern.REQUEST_RESPONSE); 296 297 OutboundEndpoint endpoint = getMuleContext().getRegistry() 298 .lookupEndpointFactory() 299 .getOutboundEndpoint(builder); 300 301 return clientInterface.process(endpoint, message); 302 } 303 304 /** 305 * sends an event request via the configured outbound router for this service. 306 * This method return immediately, but the result of the event invocation 307 * available from the returned a Future result that can be accessed later by the 308 * the returned FutureMessageResult. the Future messageResult can be queried at 309 * any time to check that the invocation has completed. A timeout is associated 310 * with the invocation, which is the maximum time in milli-seconds that the 311 * invocation should take to complete 312 * 313 * @param message the object that is the payload of the event 314 * @param timeout how long to block in milliseconds waiting for a result 315 * @return the result message if any of the invocation 316 * @throws org.mule.api.MuleException if the dispatch fails or the components or 317 * transfromers cannot be found 318 * @see org.mule.api.FutureMessageResult 319 */ 320 public FutureMessageResult sendEventAsync(final Object message, final int timeout) throws MuleException 321 { 322 Callable callable = new Callable() 323 { 324 public Object call() throws Exception 325 { 326 MuleMessage muleMessage = new DefaultMuleMessage(message, event.getMessage(), 327 event.getMuleContext()); 328 muleMessage.setOutboundProperty(MuleProperties.MULE_EVENT_TIMEOUT_PROPERTY, timeout); 329 return sendEvent(muleMessage); 330 } 331 }; 332 333 FutureMessageResult result = new FutureMessageResult(callable, event.getMuleContext()); 334 result.execute(); 335 return result; 336 } 337 338 /** 339 * sends an event request via the configured outbound router for this service. 340 * This method return immediately, but the result of the event invocation 341 * available from the returned a Future result that can be accessed later by the 342 * the returned FutureMessageResult. the Future messageResult can be queried at 343 * any time to check that the invocation has completed. A timeout is associated 344 * with the invocation, which is the maximum time in milli-seconds that the 345 * invocation should take to complete 346 * 347 * @param message the MuleMessage of the event 348 * @param timeout how long to block in milliseconds waiting for a result 349 * @return the result message if any of the invocation 350 * @throws org.mule.api.MuleException if the dispatch fails or the components or 351 * transfromers cannot be found 352 * @see org.mule.api.FutureMessageResult 353 */ 354 public FutureMessageResult sendEventAsync(final MuleMessage message, final int timeout) 355 throws MuleException 356 { 357 Callable callable = new Callable() 358 { 359 public Object call() throws Exception 360 { 361 message.setOutboundProperty(MuleProperties.MULE_EVENT_TIMEOUT_PROPERTY, timeout); 362 return sendEvent(message); 363 } 364 }; 365 366 FutureMessageResult result = new FutureMessageResult(callable, event.getMuleContext()); 367 result.execute(); 368 return result; 369 } 370 371 /** 372 * sends an event request via the configured outbound router for this service. 373 * This method return immediately, but the result of the event invocation 374 * available from the returned a Future result that can be accessed later by the 375 * the returned FutureMessageResult. the Future messageResult can be queried at 376 * any time to check that the invocation has completed. A timeout is associated 377 * with the invocation, which is the maximum time in milli-seconds that the 378 * invocation should take to complete 379 * 380 * @param message the MuleMessage of the event 381 * @param endpointUri the endpointUri to dispatch to 382 * @param timeout how long to block in milliseconds waiting for a result 383 * @return the result message if any of the invocation 384 * @throws org.mule.api.MuleException if the dispatch fails or the components or 385 * transfromers cannot be found 386 * @see org.mule.api.FutureMessageResult 387 */ 388 public FutureMessageResult sendEventAsync(final MuleMessage message, 389 final EndpointURI endpointUri, 390 final int timeout) throws MuleException 391 { 392 Callable callable = new Callable() 393 { 394 public Object call() throws Exception 395 { 396 message.setOutboundProperty(MuleProperties.MULE_EVENT_TIMEOUT_PROPERTY, timeout); 397 return sendEvent(message, endpointUri); 398 } 399 }; 400 401 FutureMessageResult result = new FutureMessageResult(callable, event.getMuleContext()); 402 result.execute(); 403 return result; 404 } 405 406 /** 407 * sends an event request via the configured outbound router for this service. 408 * This method return immediately, but the result of the event invocation 409 * available from the returned a Future result that can be accessed later by the 410 * the returned FutureMessageResult. the Future messageResult can be queried at 411 * any time to check that the invocation has completed. A timeout is associated 412 * with the invocation, which is the maximum time in milli-seconds that the 413 * invocation should take to complete 414 * 415 * @param message the MuleMessage of the event 416 * @param endpointName The endpoint name to disptch the event through. This will 417 * be looked up first on the service configuration and then on the 418 * mule manager configuration 419 * @param timeout how long to block in milliseconds waiting for a result 420 * @return the result message if any of the invocation 421 * @throws org.mule.api.MuleException if the dispatch fails or the components or 422 * transfromers cannot be found 423 * @see org.mule.api.FutureMessageResult 424 */ 425 public FutureMessageResult sendEventAsync(final MuleMessage message, 426 final String endpointName, 427 final int timeout) throws MuleException 428 { 429 Callable callable = new Callable() 430 { 431 public Object call() throws Exception 432 { 433 message.setOutboundProperty(MuleProperties.MULE_EVENT_TIMEOUT_PROPERTY, timeout); 434 return sendEvent(message, endpointName); 435 } 436 }; 437 438 FutureMessageResult result = new FutureMessageResult(callable, event.getMuleContext()); 439 result.execute(); 440 return result; 441 } 442 443 /** 444 * Depending on the session state this methods either Passes an event 445 * synchronously to the next available Mule component in the pool or via the 446 * endpoint configured for the event 447 * 448 * @param message the event message payload to send 449 * @param endpointName The endpoint name to disptch the event through. This will 450 * be looked up first on the service configuration and then on the 451 * mule manager configuration 452 * @return the return Message from the call or null if there was no result 453 * @throws org.mule.api.MuleException if the event fails to be processed by the 454 * service or the transport for the endpoint 455 */ 456 public MuleMessage sendEvent(MuleMessage message, String endpointName) throws MuleException 457 { 458 return clientInterface.send(endpointName, message); 459 } 460 461 /** 462 * This will dispatch an event asynchronously via the configured outbound 463 * endpoint on the service for this session 464 * 465 * @param message payload to dispatch 466 * @throws org.mule.api.MuleException if there is no outbound endpoint configured 467 * on the service or the events fails during dispatch 468 */ 469 public void dispatchEvent(Object message) throws MuleException 470 { 471 dispatchEvent(new DefaultMuleMessage(message, muleContext)); 472 } 473 474 /** 475 * This will dispatch an event asynchronously via the configured outbound 476 * endpoint on the service for this session 477 * 478 * @param message the message to send 479 * @throws org.mule.api.MuleException if there is no outbound endpoint configured 480 * on the service or the events fails during dispatch 481 */ 482 public void dispatchEvent(MuleMessage message) throws MuleException 483 { 484 FlowConstruct flowConstruct = session.getFlowConstruct(); 485 if (flowConstruct == null) 486 { 487 throw new IllegalStateException(CoreMessages.objectIsNull("flowConstruct").getMessage()); 488 } 489 else if (!(flowConstruct instanceof Service)) 490 { 491 throw new UnsupportedOperationException( 492 "EventContext.dispatchEvent is only supported when flow constuct is a Service"); 493 } 494 else 495 { 496 MessageProcessor processor = ((Service) flowConstruct).getOutboundMessageProcessor(); 497 if (processor == null) 498 { 499 throw new EndpointNotFoundException( 500 CoreMessages.noOutboundRouterSetOn(flowConstruct.getName())); 501 } 502 processor.process(new DefaultMuleEvent(message, RequestContext.getEvent())); 503 } 504 } 505 506 /** 507 * Depending on the session state this methods either Passes an event 508 * asynchronously to the next available Mule component in the pool or via the 509 * endpointUri configured for the event 510 * 511 * @param message the event message payload to send 512 * @param endpointUri the endpointUri to dispatc the event to first on the 513 * service configuration and then on the mule manager configuration 514 * @throws org.mule.api.MuleException if the event fails to be processed by the 515 * service or the transport for the endpointUri 516 */ 517 public void dispatchEvent(MuleMessage message, EndpointURI endpointUri) throws MuleException 518 { 519 EndpointBuilder builder = null; 520 if (endpointUri.getEndpointName() != null) 521 { 522 builder = muleContext.getRegistry().lookupEndpointBuilder(endpointUri.getEndpointName()); 523 } 524 if (builder == null) 525 { 526 builder = new EndpointURIEndpointBuilder(new URIBuilder(endpointUri)); 527 } 528 529 builder.setExchangePattern(MessageExchangePattern.ONE_WAY); 530 531 OutboundEndpoint endpoint = getMuleContext().getRegistry() 532 .lookupEndpointFactory() 533 .getOutboundEndpoint(builder); 534 535 clientInterface.process(endpoint, message); } 536 537 /** 538 * Depending on the session state this methods either Passes an event 539 * asynchronously to the next available Mule component in the pool or via the 540 * endpoint configured for the event 541 * 542 * @param message the event message payload to send 543 * @param endpointName The endpoint name to disptch the event through. This will 544 * be looked up first on the service configuration and then on the 545 * mule manager configuration 546 * @throws org.mule.api.MuleException if the event fails to be processed by the 547 * service or the transport for the endpoint 548 */ 549 public void dispatchEvent(MuleMessage message, String endpointName) throws MuleException 550 { 551 EndpointBuilder builder = muleContext.getRegistry().lookupEndpointBuilder(endpointName); 552 553 if (builder == null) 554 { 555 builder = new EndpointURIEndpointBuilder(new URIBuilder(endpointName, muleContext)); 556 } 557 558 builder.setExchangePattern(MessageExchangePattern.ONE_WAY); 559 560 OutboundEndpoint endpoint = getMuleContext().getRegistry() 561 .lookupEndpointFactory() 562 .getOutboundEndpoint(builder); 563 564 clientInterface.process(endpoint, message); 565 } 566 567 /** 568 * Depending on the session state this methods either Passes an event 569 * asynchronously to the next available Mule component in the pool or via the 570 * endpoint configured for the event 571 * 572 * @param message the event message payload to send 573 * @param endpoint The endpoint name to disptch the event through. 574 * @throws org.mule.api.MuleException if the event fails to be processed by the 575 * service or the transport for the endpoint 576 */ 577 public void dispatchEvent(MuleMessage message, OutboundEndpoint endpoint) throws MuleException 578 { 579 clientInterface.process(endpoint, message); 580 } 581 582 /** 583 * Requests a synchronous receive of an event on the service 584 * 585 * @param endpoint the endpoint identifing the endpointUri on ewhich the event 586 * will be received 587 * @param timeout time in milliseconds before the request timesout 588 * @return The requested event or null if the request times out 589 * @throws org.mule.api.MuleException if the request operation fails 590 */ 591 public MuleMessage requestEvent(InboundEndpoint endpoint, long timeout) throws MuleException 592 { 593 return clientInterface.request(endpoint, timeout); 594 } 595 596 /** 597 * Requests a synchronous receive of an event on the service 598 * 599 * @param endpointName the endpoint identifing the endpointUri on ewhich the 600 * event will be received 601 * @param timeout time in milliseconds before the request timesout 602 * @return The requested event or null if the request times out 603 * @throws org.mule.api.MuleException if the request operation fails 604 */ 605 public MuleMessage requestEvent(String endpointName, long timeout) throws MuleException 606 { 607 return clientInterface.request(endpointName, timeout); 608 } 609 610 /** 611 * Requests a synchronous receive of an event on the service 612 * 613 * @param endpointUri the endpointUri on which the event will be received 614 * @param timeout time in milliseconds before the request timesout 615 * @return The requested event or null if the request times out 616 * @throws org.mule.api.MuleException if the request operation fails 617 */ 618 public MuleMessage requestEvent(EndpointURI endpointUri, long timeout) throws MuleException 619 { 620 InboundEndpoint endpoint = getMuleContext().getRegistry().lookupEndpointFactory().getInboundEndpoint( 621 endpointUri); 622 return requestEvent(endpoint, timeout); 623 } 624 625 /** 626 * @return the service descriptor of the service that received this event 627 */ 628 public FlowConstruct getFlowConstruct() 629 { 630 return event.getFlowConstruct(); 631 } 632 633 /** 634 * Determines whether the default processing for this event will be executed. By 635 * default, the Mule server will route events according to a components 636 * configuration. The user can override this behaviour by obtaining a reference 637 * to the MuleEvent context, either by implementing 638 * <code>org.mule.api.lifecycle.Callable</code> or calling 639 * <code>RequestContext.getEventContext</code> to obtain the MuleEventContext for 640 * the current thread. The user can programmatically control how events are 641 * dispatched. 642 * 643 * @return Returns true is the user has set stopFurtherProcessing. 644 * @see org.mule.api.MuleEventContext 645 * @see org.mule.api.lifecycle.Callable 646 */ 647 public boolean isStopFurtherProcessing() 648 { 649 return RequestContext.getEvent().isStopFurtherProcessing(); 650 } 651 652 /** 653 * Determines whether the default processing for this event will be executed. By 654 * default, the Mule server will route events according to a components 655 * configuration. The user can override this behaviour by obtaining a reference 656 * to the MuleEvent context, either by implementing 657 * <code>org.mule.api.lifecycle.Callable</code> or calling 658 * <code>RequestContext.getEventContext</code> to obtain the MuleEventContext for 659 * the current thread. The user can programmatically control how events are 660 * dispached. 661 * 662 * @param stopFurtherProcessing the value to set. 663 */ 664 public void setStopFurtherProcessing(boolean stopFurtherProcessing) 665 { 666 event.setStopFurtherProcessing(stopFurtherProcessing); 667 } 668 669 /** 670 * An outputstream the can optionally be used write response data to an incoming 671 * message. 672 * 673 * @return an output stream if one has been made available by the message 674 * receiver that received the message 675 */ 676 public OutputStream getOutputStream() 677 { 678 return event.getOutputStream(); 679 } 680 681 public EndpointURI getEndpointURI() 682 { 683 return event.getEndpoint().getEndpointURI(); 684 } 685 686 public MessageExchangePattern getExchangePattern() 687 { 688 return event.getEndpoint().getExchangePattern(); 689 } 690 691 /** 692 * Returns the transaction for the current event or null if there is no 693 * transaction in progresss 694 * 695 * @return the transaction for the current event or null if there is no 696 * transaction in progresss 697 */ 698 public Transaction getTransaction() 699 { 700 return TransactionCoordination.getInstance().getTransaction(); 701 } 702 703 /** 704 * Get the timeout value associated with the event 705 * 706 * @return the timeout for the event 707 */ 708 public int getTimeout() 709 { 710 return event.getTimeout(); 711 } 712 713 /** 714 * Gets the encoding for the current message. For potocols that send encoding 715 * Information with the message, this method should be overriden to expose the 716 * transport encoding, otherwise the default encoding in the Mule configuration 717 * will be used 718 * 719 * @return the encoding for this message. This method must never return null 720 */ 721 public String getEncoding() 722 { 723 return event.getEncoding(); 724 } 725 726 public MuleSession getSession() 727 { 728 return event.getSession(); 729 } 730 731 @Override 732 public String toString() 733 { 734 return event.toString(); 735 } 736 737 public MuleContext getMuleContext() 738 { 739 return event.getMuleContext(); 740 } 741 742 }