View Javadoc

1   /*
2    * $Id: JcaComponent.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.module.jca;
12  
13  import org.mule.RequestContext;
14  import org.mule.api.DefaultMuleException;
15  import org.mule.api.MessagingException;
16  import org.mule.api.MuleEvent;
17  import org.mule.api.MuleException;
18  import org.mule.api.component.LifecycleAdapter;
19  import org.mule.api.construct.FlowConstruct;
20  import org.mule.api.lifecycle.InitialisationException;
21  import org.mule.api.model.EntryPointResolverSet;
22  import org.mule.component.AbstractJavaComponent;
23  import org.mule.config.i18n.CoreMessages;
24  import org.mule.config.i18n.Message;
25  import org.mule.module.jca.i18n.JcaMessages;
26  import org.mule.work.AbstractMuleEventWork;
27  
28  import javax.resource.spi.UnavailableException;
29  import javax.resource.spi.endpoint.MessageEndpoint;
30  import javax.resource.spi.endpoint.MessageEndpointFactory;
31  import javax.resource.spi.work.WorkEvent;
32  import javax.resource.spi.work.WorkListener;
33  import javax.resource.spi.work.WorkManager;
34  
35  public class JcaComponent extends AbstractJavaComponent implements WorkListener
36  {
37      protected MessageEndpointFactory messageEndpointFactory;
38      protected WorkManager workManager;
39  
40      public JcaComponent(MessageEndpointFactory messageEndpointFactory,
41                          EntryPointResolverSet entryPointResolverSet,
42                          FlowConstruct flowConstruct,
43                          WorkManager workManager)
44      {
45          this.messageEndpointFactory = messageEndpointFactory;
46          this.entryPointResolverSet = entryPointResolverSet;
47          this.flowConstruct = flowConstruct;
48          this.workManager = workManager;
49      }
50  
51      /*
52       * The service ins actually managed by the Application Server container,Since the
53       * instance might be pooled by the server, we should use the
54       * MessageEndPointFactory to delegate the request for creation to the container.
55       * The container might create a Proxy object to intercept the actual method call
56       * to implement transaction,security related functionalities
57       */
58      public Object getManagedInstance() throws UnavailableException, MuleException
59      {
60          return messageEndpointFactory.createEndpoint(null);
61      }
62  
63      @Override
64      public Object doInvoke(MuleEvent event)
65      {
66          try
67          {
68              workManager.scheduleWork(new MuleJcaWorker(event), WorkManager.INDEFINITE, null, this);
69          }
70          catch (Exception e)
71          {
72              logger.error(CoreMessages.failedToInvoke("Service: " + flowConstruct.getName()));
73          }
74          return null;
75      }
76  
77      public Class getObjectType()
78      {
79          return MessageEndpoint.class;
80      }
81  
82      @Override
83      protected LifecycleAdapter borrowComponentLifecycleAdaptor() throws Exception
84      {
85          // Template method unused because doOnCall and doOnEvent have been overridden
86          return null;
87      }
88  
89      @Override
90      protected void returnComponentLifecycleAdaptor(LifecycleAdapter lifecycleAdapter)
91      {
92          // Template method unused because doOnCall and doOnEvent have been overridden
93      }
94  
95      @Override
96      protected void doInitialise() throws InitialisationException
97      {
98          // no-op no object-factory
99      }
100 
101     public class MuleJcaWorker extends AbstractMuleEventWork
102     {
103 
104         MuleJcaWorker(MuleEvent event)
105         {
106             super(event);
107         }
108 
109         public void doRun()
110         {
111 
112             if (logger.isTraceEnabled())
113             {
114                 logger.trace("MuleJcaWorker: async MuleEvent for Mule  JCA EndPoint " + flowConstruct.getName());
115             }
116             try
117             {
118                 // Invoke method
119                 entryPointResolverSet.invoke(getManagedInstance(), RequestContext.getEventContext());
120             }
121             catch (Exception e)
122             {
123                 if (e instanceof UnavailableException)
124                 {
125                     Message message = JcaMessages.cannotAllocateManagedInstance();
126                     logger.error(message);
127                     flowConstruct.getExceptionListener().handleException(new DefaultMuleException(message, e), event);
128                 }
129                 else if (e instanceof MessagingException)
130                 {
131                     logger.error("Failed to execute  JCAEndPoint " + e.getMessage(), e);
132                     flowConstruct.getExceptionListener().handleException(e, event);
133                 }
134                 else
135                 {
136                     flowConstruct.getExceptionListener().handleException(
137                         new DefaultMuleException(CoreMessages.eventProcessingFailedFor(flowConstruct.getName()), e), event);
138                 }
139             }
140         }
141     }
142 
143     public void workAccepted(WorkEvent arg0)
144     {
145         // TODO Auto-generated method stub
146     }
147 
148     public void workCompleted(WorkEvent arg0)
149     {
150         // TODO Auto-generated method stub
151     }
152 
153     public void workRejected(WorkEvent arg0)
154     {
155         // TODO Auto-generated method stub
156     }
157 
158     public void workStarted(WorkEvent arg0)
159     {
160         // TODO Auto-generated method stub
161     }
162 
163 }