View Javadoc

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