KickJava   Java API By Example, From Geeks To Geeks.

Java > Open Source Codes > org > apache > roller > ui > rendering > util > cache > WeblogCacheWarmupJob


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.util.cache;
20
21 import java.util.HashMap JavaDoc;
22 import java.util.Iterator JavaDoc;
23 import java.util.List JavaDoc;
24 import java.util.Map JavaDoc;
25 import org.apache.commons.logging.Log;
26 import org.apache.commons.logging.LogFactory;
27 import org.apache.roller.RollerException;
28 import org.apache.roller.business.runnable.Job;
29 import org.apache.roller.config.RollerConfig;
30 import org.apache.roller.model.RollerFactory;
31 import org.apache.roller.model.UserManager;
32 import org.apache.roller.pojos.StaticTemplate;
33 import org.apache.roller.pojos.Template;
34 import org.apache.roller.pojos.WebsiteData;
35 import org.apache.roller.ui.rendering.Renderer;
36 import org.apache.roller.ui.rendering.RendererManager;
37 import org.apache.roller.ui.rendering.model.ModelLoader;
38 import org.apache.roller.ui.rendering.util.WeblogFeedCache;
39 import org.apache.roller.ui.rendering.util.WeblogFeedRequest;
40 import org.apache.roller.util.cache.CachedContent;
41
42
43 /**
44  * EXPERIMENTAL!!
45  *
46  * A job which will "warm up" some of the rendering layer caches by iterating
47  * over all weblogs in the system and rendering a set of their content to put
48  * in the caches for later use.
49  *
50  * Currently only supports warming up the feed cache.
51  */
52 public class WeblogCacheWarmupJob implements Job {
53     
54     private static Log log = LogFactory.getLog(WeblogCacheWarmupJob.class);
55     
56     // inputs from the user
57 private Map JavaDoc inputs = null;
58     
59     
60     public void execute() {
61         
62         log.debug("starting");
63         
64         // check inputs to see what work we are going to do
65 if(inputs != null) {
66             
67             // what weblogs will we handle?
68 List JavaDoc weblogs = (List JavaDoc) inputs.get("weblogs");
69             if(weblogs == null) {
70                 return;
71             }
72             
73             // should we do rss entries feeds?
74 if("true".equals((String JavaDoc) inputs.get("feed-entries-rss"))) {
75                 this.warmupFeedCache(weblogs, "entries", "rss");
76             }
77             
78             // should we do atom entries feeds?
79 if("true".equals((String JavaDoc) inputs.get("feed-entries-atom"))) {
80                 this.warmupFeedCache(weblogs, "entries", "atom");
81             }
82         }
83         
84         log.debug("finished");
85     }
86     
87     
88     public Map JavaDoc output() {
89        return null;
90     }
91     
92     
93     public void input(Map JavaDoc input) {
94         this.inputs = input;
95     }
96     
97     
98     private void warmupFeedCache(List JavaDoc weblogs, String JavaDoc type, String JavaDoc format) {
99         
100         if(weblogs == null) {
101             return;
102         }
103         
104         // we are working on the feed cache
105 WeblogFeedCache feedCache = WeblogFeedCache.getInstance();
106         
107         long start = System.currentTimeMillis();
108         
109         Iterator JavaDoc allWeblogs = weblogs.iterator();
110         String JavaDoc weblogHandle = null;
111         while(allWeblogs.hasNext()) {
112             weblogHandle = (String JavaDoc) allWeblogs.next();
113             log.debug("doing weblog "+weblogHandle);
114             
115             try {
116                 // we need a feed request to represent the data
117 WeblogFeedRequest feedRequest = new WeblogFeedRequest();
118                 feedRequest.setWeblogHandle(weblogHandle);
119                 feedRequest.setType(type);
120                 feedRequest.setFormat(format);
121                 
122                 
123                 // populate the rendering model
124 HashMap JavaDoc model = new HashMap JavaDoc();
125                 Map JavaDoc initData = new HashMap JavaDoc();
126                 initData.put("request", null);
127                 initData.put("feedRequest", feedRequest);
128                 initData.put("weblogRequest", feedRequest);
129                 
130                 // Load models for feeds
131 String JavaDoc feedModels = RollerConfig.getProperty("rendering.feedModels");
132                 ModelLoader.loadModels(feedModels, model, initData, true);
133                 
134                 // TODO: re-enable custom models when they are actually used
135 // Load weblog custom models
136 //ModelLoader.loadCustomModels(weblog, model, initData);
137
138                 
139                 // lookup Renderer we are going to use
140 Renderer renderer = null;
141                 Template template = new StaticTemplate("templates/feeds/weblog-"+type+"-"+format+".vm", null, "velocity");
142                 renderer = RendererManager.getRenderer(template);
143                 
144                 
145                 // render content. use default size of about 24K for a standard page
146 CachedContent rendererOutput = new CachedContent(24567);
147                 renderer.render(model, rendererOutput.getCachedWriter());
148                 
149                 
150                 // flush rendered output and close
151 rendererOutput.flush();
152                 rendererOutput.close();
153                 
154                 // now just put it in the cache
155 String JavaDoc key = feedCache.generateKey(feedRequest);
156                 feedCache.put(key, rendererOutput);
157                 
158             } catch(Exception JavaDoc e) {
159                 // bummer, error during rendering
160 log.error("Error rendering for weblog "+weblogHandle, e);
161             }
162         }
163         
164         long end = System.currentTimeMillis();
165         long time = (end-start)*1000;
166         
167         log.info("Completed warmup for "+type+"/"+format+" in "+time+" secs.");
168         
169     }
170     
171 }
172
Popular Tags