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