View Javadoc

1   /*
2    * $Id: FeedSplitter.java 21056 2011-01-21 08:29:01Z dirk.olmes $
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  package org.mule.module.rss.routing;
11  
12  import org.mule.DefaultMuleMessage;
13  import org.mule.api.MessagingException;
14  import org.mule.api.MuleEvent;
15  import org.mule.api.MuleException;
16  import org.mule.api.MuleMessage;
17  import org.mule.api.routing.filter.Filter;
18  import org.mule.api.transformer.TransformerException;
19  import org.mule.module.rss.transformers.ObjectToRssFeed;
20  import org.mule.routing.AbstractSplitter;
21  
22  import com.sun.syndication.feed.synd.SyndEntry;
23  import com.sun.syndication.feed.synd.SyndFeed;
24  
25  import java.util.ArrayList;
26  import java.util.Comparator;
27  import java.util.List;
28  import java.util.Set;
29  import java.util.TreeSet;
30  
31  import org.apache.commons.logging.Log;
32  import org.apache.commons.logging.LogFactory;
33  
34  /**
35   * Will split the feed into entries. This message processor also filters out any entries that
36   * are older than the last one read. The filter can be configured with a date from
37   * which to accept feed entries
38   */
39  public class FeedSplitter extends AbstractSplitter
40  {
41      public static final String FEED_PROPERTY = "feed.object";
42  
43      /**
44       * logger used by this class
45       */
46      protected transient final Log logger = LogFactory.getLog(FeedSplitter.class);
47  
48      private Filter entryFilter;
49      private ObjectToRssFeed objectToFeed = new ObjectToRssFeed();
50  
51      public FeedSplitter()
52      {
53          // By default set the filter so that entries are only read once
54          entryFilter = new EntryLastUpdatedFilter(null);
55      }
56  
57      @Override
58      protected List<MuleMessage> splitMessage(MuleEvent event) throws MuleException
59      {
60          List<MuleMessage> messages = new ArrayList<MuleMessage>();
61  
62          if (event.getMessage().getInboundProperty("Content-Length", -1) == 0)
63          {
64              logger.info("Feed has no content, ignoring");
65              return messages;
66          }
67  
68          try
69          {
70              SyndFeed feed = transformToFeed(event);
71  
72              Set<SyndEntry> entries = new TreeSet<SyndEntry>(new EntryComparator());
73              entries.addAll(feed.getEntries());
74  
75              for (SyndEntry entry : entries)
76              {
77                  MuleMessage entryMessage = new DefaultMuleMessage(entry, event.getMuleContext());
78                  if ((entryFilter != null) && !entryFilter.accept(entryMessage))
79                  {
80                      continue;
81                  }
82  
83                  entryMessage.setInvocationProperty(FEED_PROPERTY, feed);
84                  messages.add(entryMessage);
85              }
86              return messages;
87          }
88          catch (MuleException e)
89          {
90              throw new MessagingException(e.getI18nMessage(), event, e);
91          }
92      }
93  
94      protected SyndFeed transformToFeed(MuleEvent event) throws TransformerException
95      {
96          Object payload = event.getMessage().getPayload();
97          if (payload instanceof SyndFeed)
98          {
99              return (SyndFeed) payload;
100         }
101         else
102         {
103             return (SyndFeed) objectToFeed.transform(payload);
104         }
105     }
106 
107     public Filter getEntryFilter()
108     {
109         return entryFilter;
110     }
111 
112     public void setEntryFilter(Filter entryFilter)
113     {
114         this.entryFilter = entryFilter;
115     }
116 
117     static class EntryComparator implements Comparator<SyndEntry>
118     {
119         public int compare(SyndEntry e1, SyndEntry e2)
120         {
121             if (e1.getPublishedDate().before(e2.getPublishedDate()))
122             {
123                 return -1;
124             }
125             else if (e1.equals(e2))
126             {
127                 return 0;
128             }
129             else
130             {
131                 return 1;
132             }
133         }
134     }
135 }