View Javadoc
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.transport.xmpp;
8   
9   import org.mule.api.MuleEvent;
10  import org.mule.api.MuleException;
11  import org.mule.api.MuleMessage;
12  import org.mule.api.construct.FlowConstruct;
13  import org.mule.api.endpoint.InboundEndpoint;
14  import org.mule.api.lifecycle.CreateException;
15  import org.mule.transport.AbstractConnector;
16  import org.mule.transport.AbstractMessageReceiver;
17  
18  import javax.resource.spi.work.Work;
19  import javax.resource.spi.work.WorkException;
20  import javax.resource.spi.work.WorkManager;
21  
22  import org.jivesoftware.smack.PacketListener;
23  import org.jivesoftware.smack.packet.Message;
24  import org.jivesoftware.smack.packet.Packet;
25  
26  /** 
27   * <code>XmppMessageReceiver</code> is responsible for receiving Mule events over XMPP. 
28   */
29  public class XmppMessageReceiver extends AbstractMessageReceiver implements PacketListener
30  {
31  //    private XMPPConnection xmppConnection = null;
32      private XmppConversation xmppConversation;
33  
34      public XmppMessageReceiver(AbstractConnector connector, FlowConstruct flowConstruct, InboundEndpoint endpoint)
35              throws CreateException
36      {
37          super(connector, flowConstruct, endpoint);
38          XmppConnector xmppConnector = (XmppConnector) connector;
39          xmppConversation = xmppConnector.getConversationFactory().create(endpoint);
40      }
41  
42      @Override
43      protected void doConnect() throws Exception
44      {
45          xmppConversation.connect();
46  //        try
47  //        {
48  //            XmppConnector cnn = (XmppConnector) connector;
49  //            xmppConnection = cnn.createXmppConnection(endpoint.getEndpointURI());
50  //            if (endpoint.getFilter() instanceof PacketFilter)
51  //            {
52  //                xmppConnection.addPacketListener(this, (PacketFilter) endpoint.getFilter());
53  //            }
54  //            else
55  //            {
56  //                PacketFilter filter = new PacketTypeFilter(Message.class);
57  //                xmppConnection.addPacketListener(this, filter);
58  //            }
59  //        }
60  //        catch (XMPPException e)
61  //        {
62  //            throw new ConnectException(CoreMessages.failedToCreate("XMPP Connection"), e, this);
63  //        }
64      }
65  
66      @Override
67      protected void doDisconnect() throws Exception
68      {
69          xmppConversation.disconnect();
70  //        if (xmppConnection != null)
71  //        {
72  //            xmppConnection.removePacketListener(this);
73  //            xmppConnection.disconnect();
74  //        }
75      }
76  
77      // TODO xmpp: consider lifecycle
78      @Override
79      protected void doStart() throws MuleException
80      {
81          // nothing to do
82      }
83  
84      // TODO xmpp: consider lifecycle
85      @Override
86      protected void doStop() throws MuleException
87      {
88          // nothing to do
89      }
90  
91      @Override
92      protected void doDispose()
93      {
94          xmppConversation = null;
95      }
96  
97      protected Work createWork(Packet message)
98      {
99          return new XMPPWorker(message);
100     }
101 
102     /** @see org.jivesoftware.smack.PacketListener#processPacket(org.jivesoftware.smack.packet.Packet) */
103     public void processPacket(Packet packet)
104     {
105         if (logger.isDebugEnabled())
106         {
107             logger.debug("processing packet: " + packet.toXML());
108         }
109 
110         Work work = createWork(packet);
111         try
112         {
113             getWorkManager().scheduleWork(work, WorkManager.INDEFINITE, null, connector);
114         }
115         catch (WorkException e)
116         {
117             logger.error("Xmpp Server receiver work failed: " + e.getMessage(), e);
118         }
119     }
120 
121     private class XMPPWorker implements Work
122     {
123         Packet packet = null;
124 
125         public XMPPWorker(Packet message)
126         {
127             this.packet = message;
128         }
129 
130         /** Accept requests from a given TCP port */
131         public void run()
132         {
133             try
134             {
135                 if (logger.isDebugEnabled())
136                 {
137                     logger.debug("Processing XMPP packet from: " + packet.getFrom());
138                 }
139 
140                 MuleMessage message = createMuleMessage(packet, endpoint.getEncoding());
141                 MuleEvent event = routeMessage(message);
142                 MuleMessage returnMessage = event == null ? null : event.getMessage();
143 
144                 if (returnMessage != null && packet instanceof Message)
145                 {
146                     returnMessage.applyTransformers(event, connector.getDefaultResponseTransformers(endpoint));
147                     Packet result = (Packet) returnMessage.getPayload();
148 //                    xmppConnection.sendPacket(result);
149                 }
150             }
151             catch (Exception e)
152             {
153                 getConnector().getMuleContext().getExceptionListener().handleException(e);
154             }
155         }
156 
157         public void release()
158         {
159             // template method
160         }
161     }
162 }