KickJava   Java API By Example, From Geeks To Geeks.

Java > Open Source Codes > org > apache > roller > ui > rendering > servlets > PlanetFeedServlet


1 /*
2  * Licensed to the Apache Software Foundation (ASF) under one or more
3  * contributor license agreements. The ASF licenses this file to You
4  * under the Apache License, Version 2.0 (the "License"); you may not
5  * use this file except in compliance with the License.
6  * You may obtain a copy of the License at
7  *
8  * http://www.apache.org/licenses/LICENSE-2.0
9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License. For additional information regarding
15  * copyright in this work, please see the NOTICE file in the top level
16  * directory of this distribution.
17  */

18
19 package org.apache.roller.ui.rendering.servlets;
20
21 import java.io.IOException JavaDoc;
22 import java.util.Date JavaDoc;
23 import java.util.HashMap JavaDoc;
24 import javax.servlet.ServletConfig JavaDoc;
25 import javax.servlet.ServletException JavaDoc;
26 import javax.servlet.http.HttpServlet JavaDoc;
27 import javax.servlet.http.HttpServletRequest JavaDoc;
28 import javax.servlet.http.HttpServletResponse JavaDoc;
29 import org.apache.commons.logging.Log;
30 import org.apache.commons.logging.LogFactory;
31 import org.apache.roller.RollerException;
32 import org.apache.roller.config.RollerRuntimeConfig;
33 import org.apache.roller.model.PlanetManager;
34 import org.apache.roller.model.RollerFactory;
35 import org.apache.roller.pojos.StaticTemplate;
36 import org.apache.roller.pojos.Template;
37 import org.apache.roller.ui.rendering.Renderer;
38 import org.apache.roller.ui.rendering.RendererManager;
39 import org.apache.roller.ui.rendering.model.UtilitiesModel;
40 import org.apache.roller.ui.rendering.util.PlanetCache;
41 import org.apache.roller.ui.rendering.util.PlanetRequest;
42 import org.apache.roller.ui.rendering.util.ModDateHeaderUtil;
43 import org.apache.roller.util.cache.CachedContent;
44
45
46 /**
47  * Planet Roller (i.e. NOT for Planet Tool) RSS feed.
48  *
49  * @web.servlet name="PlanetFeedServlet" load-on-startup="7"
50  * @web.servlet-mapping url-pattern="/planetrss/*"
51  */

52 public class PlanetFeedServlet extends HttpServlet JavaDoc {
53     
54     private static Log log = LogFactory.getLog(PlanetFeedServlet.class);
55     
56     private PlanetCache planetCache = null;
57     
58     
59     /**
60      * Init method for this servlet
61      */

62     public void init(ServletConfig JavaDoc servletConfig) throws ServletException JavaDoc {
63         
64         super.init(servletConfig);
65         
66         log.info("Initializing PlanetRssServlet");
67         
68         this.planetCache = PlanetCache.getInstance();
69     }
70     
71     
72     /**
73      * Handle GET requests for weblog pages.
74      */

75     public void doGet(HttpServletRequest JavaDoc request, HttpServletResponse JavaDoc response)
76             throws ServletException JavaDoc, IOException JavaDoc {
77         
78         log.debug("Entering");
79         
80         PlanetManager planet = null;
81         try {
82             planet = RollerFactory.getRoller().getPlanetManager();
83         } catch (RollerException ex) {
84             // error getting planet manager :(
85
log.error("Unable to get planet manager", ex);
86             response.sendError(HttpServletResponse.SC_INTERNAL_SERVER_ERROR);
87             return;
88         }
89         
90         PlanetRequest planetRequest = null;
91         try {
92             planetRequest = new PlanetRequest(request);
93         } catch (Exception JavaDoc e) {
94             // some kind of error parsing the request
95
log.debug("error creating planet request", e);
96             response.sendError(HttpServletResponse.SC_NOT_FOUND);
97             return;
98         }
99         
100         // figure planet last modified date
101
Date JavaDoc lastModified = planetCache.getLastModified();
102         
103         // Respond with 304 Not Modified if it is not modified.
104
if (ModDateHeaderUtil.respondIfNotModified(request,response,lastModified.getTime())) {
105             return;
106         }
107
108         // set content type
109
String JavaDoc accepts = request.getHeader("Accept");
110         String JavaDoc userAgent = request.getHeader("User-Agent");
111         if (accepts != null && userAgent != null
112             && accepts.indexOf("*/*") != -1 && userAgent.startsWith("Mozilla")) {
113             // client is a browser and now that we offer styled feeds we want
114
// browsers to load the page rather than popping up the download
115
// dialog, so we provide a content-type that browsers will display
116
response.setContentType("text/xml");
117         } else {
118             response.setContentType("application/rss+xml; charset=utf-8");
119         }
120
121         // set last-modified date
122
ModDateHeaderUtil.setLastModifiedHeader(response,lastModified.getTime());
123
124         // cached content checking
125
String JavaDoc cacheKey = PlanetCache.CACHE_ID+":"+this.generateKey(planetRequest);
126         CachedContent entry = (CachedContent) planetCache.get(cacheKey);
127         if(entry != null) {
128             response.setContentLength(entry.getContent().length);
129             response.getOutputStream().write(entry.getContent());
130             return;
131             
132         }
133         
134         
135         // looks like we need to render content
136
HashMap JavaDoc model = new HashMap JavaDoc();
137         try {
138             // populate the rendering model
139
if (request.getParameter("group") != null) {
140                 model.put("group", planet.getGroup(request.getParameter("group")));
141             }
142             model.put("planet", planet);
143             model.put("date", new Date JavaDoc());
144             model.put("utils", new UtilitiesModel());
145             model.put("absoluteSite", RollerRuntimeConfig.getAbsoluteContextURL());
146             model.put("feedStyle", new Boolean JavaDoc(RollerRuntimeConfig.getBooleanProperty("site.newsfeeds.styledFeeds")));
147
148             int entryCount =
149                     RollerRuntimeConfig.getIntProperty("site.newsfeeds.defaultEntries");
150             int maxEntries =
151                     RollerRuntimeConfig.getIntProperty("site.newsfeeds.maxEntries");
152             String JavaDoc sCount = request.getParameter("count");
153             if (sCount!=null) {
154                 try {
155                     entryCount = Integer.parseInt(sCount);
156                 } catch (NumberFormatException JavaDoc e) {
157                     log.warn("Improperly formatted count parameter");
158                 }
159                 if ( entryCount > maxEntries ) entryCount = maxEntries;
160                 if ( entryCount < 0 ) entryCount = 0;
161             }
162             model.put("entryCount", new Integer JavaDoc(entryCount));
163             
164         } catch (RollerException ex) {
165             log.error("Error loading model objects for page", ex);
166             
167             if(!response.isCommitted()) response.reset();
168             response.sendError(HttpServletResponse.SC_INTERNAL_SERVER_ERROR);
169             return;
170         }
171         
172         
173         // lookup Renderer we are going to use
174
Renderer renderer = null;
175         try {
176             log.debug("Looking up renderer");
177             Template template = new StaticTemplate("templates/planet/planetrss.vm", null, "velocity");
178             renderer = RendererManager.getRenderer(template);
179         } catch(Exception JavaDoc e) {
180             // nobody wants to render my content :(
181
log.error("Couldn't find renderer for planet rss", e);
182             
183             if(!response.isCommitted()) response.reset();
184             response.sendError(HttpServletResponse.SC_NOT_FOUND);
185             return;
186         }
187         
188         // render content. use default size of about 24K for a standard page
189
CachedContent rendererOutput = new CachedContent(24567);
190         try {
191             log.debug("Doing rendering");
192             renderer.render(model, rendererOutput.getCachedWriter());
193             
194             // flush rendered output and close
195
rendererOutput.flush();
196             rendererOutput.close();
197         } catch(Exception JavaDoc e) {
198             // bummer, error during rendering
199
log.error("Error during rendering for planet rss", e);
200             
201             if(!response.isCommitted()) response.reset();
202             response.sendError(HttpServletResponse.SC_NOT_FOUND);
203             return;
204         }
205         
206         
207         // post rendering process
208

209         // flush rendered content to response
210
log.debug("Flushing response output");
211         response.setContentLength(rendererOutput.getContent().length);
212         response.getOutputStream().write(rendererOutput.getContent());
213         
214         // cache rendered content.
215
this.planetCache.put(cacheKey, rendererOutput);
216         
217         log.debug("Exiting");
218     }
219
220     
221     /**
222      * Generate a cache key from a parsed planet request.
223      * This generates a key of the form ...
224      *
225      * <context>/<type>/<language>[/user]
226      * or
227      * <context>/<type>[/flavor]/<language>[/excerpts]
228      *
229      *
230      * examples ...
231      *
232      * planet/page/en
233      * planet/feed/rss/en/excerpts
234      *
235      */

236     private String JavaDoc generateKey(PlanetRequest planetRequest) {
237         
238         StringBuffer JavaDoc key = new StringBuffer JavaDoc();
239         key.append(planetRequest.getContext());
240         key.append("/");
241         key.append(planetRequest.getType());
242         
243         if(planetRequest.getFlavor() != null) {
244             key.append("/").append(planetRequest.getFlavor());
245         }
246         
247         // add language
248
key.append("/").append(planetRequest.getLanguage());
249         
250         if(planetRequest.getFlavor() != null) {
251             // add excerpts
252
if(planetRequest.isExcerpts()) {
253                 key.append("/excerpts");
254             }
255         } else {
256             // add login state
257
if(planetRequest.getAuthenticUser() != null) {
258                 key.append("/user=").append(planetRequest.getAuthenticUser());
259             }
260         }
261         
262         return key.toString();
263     }
264     
265 }
266
Popular Tags