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.weblogger.ui.rendering.util.cache;
    20  
    21  import java.util.HashMap;
    22  import java.util.Iterator;
    23  import java.util.List;
    24  import java.util.Map;
    25  import org.apache.commons.logging.Log;
    26  import org.apache.commons.logging.LogFactory;
    27  import org.apache.roller.weblogger.WebloggerException;
    28  import org.apache.roller.weblogger.business.runnable.Job;
    29  import org.apache.roller.weblogger.config.WebloggerConfig;
    30  import org.apache.roller.weblogger.business.WebloggerFactory;
    31  import org.apache.roller.weblogger.business.UserManager;
    32  import org.apache.roller.weblogger.pojos.StaticTemplate;
    33  import org.apache.roller.weblogger.pojos.Template;
    34  import org.apache.roller.weblogger.pojos.Weblog;
    35  import org.apache.roller.weblogger.ui.rendering.Renderer;
    36  import org.apache.roller.weblogger.ui.rendering.RendererManager;
    37  import org.apache.roller.weblogger.ui.rendering.model.ModelLoader;
    38  import org.apache.roller.weblogger.ui.rendering.util.cache.WeblogFeedCache;
    39  import org.apache.roller.weblogger.ui.rendering.util.WeblogFeedRequest;
    40  import org.apache.roller.weblogger.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   */
         /* 
    P/P   *  Method: void org.apache.roller.weblogger.ui.rendering.util.cache.WeblogCacheWarmupJob()
          * 
          *  Postconditions:
          *    this.inputs == null
          */
    52  public class WeblogCacheWarmupJob implements Job {
    53      
             /* 
    P/P       *  Method: org.apache.roller.weblogger.ui.rendering.util.cache.WeblogCacheWarmupJob__static_init
              * 
              *  Postconditions:
              *    init'ed(log)
              */
    54      private static Log log = LogFactory.getLog(WeblogCacheWarmupJob.class);
    55      
    56      // inputs from the user
    57      private Map inputs = null;
    58      
    59      
    60      public void execute() {
    61          
                 /* 
    P/P           *  Method: void execute()
                  * 
                  *  Preconditions:
                  *    log != null
                  *    init'ed(this.inputs)
                  *    (soft) org/apache/roller/weblogger/ui/rendering/util/cache/WeblogFeedCache.log != null
                  *    (soft) org/apache/roller/weblogger/ui/rendering/util/cache/WeblogFeedCache.singletonInstance != null
                  *    (soft) init'ed(org/apache/roller/weblogger/ui/rendering/util/cache/WeblogFeedCache.singletonInstance.cacheEnabled)
                  *    (soft) org/apache/roller/weblogger/ui/rendering/util/cache/WeblogFeedCache.singletonInstance.contentCache != null
                  * 
                  *  Test Vectors:
                  *    this.inputs: Addr_Set{null}, Inverse{null}
                  *    java.lang.String:equals(...)@74: {0}, {1}
                  *    java.lang.String:equals(...)@79: {0}, {1}
                  *    java.util.Map:get(...)@68: Inverse{null}, Addr_Set{null}
                  */
    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 weblogs = (List) inputs.get("weblogs");
    69              if(weblogs == null) {
    70                  return;
    71              }
    72              
    73              // should we do rss entries feeds?
    74              if("true".equals((String) 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) inputs.get("feed-entries-atom"))) {
    80                  this.warmupFeedCache(weblogs, "entries", "atom");
    81              }
    82          }
    83          
    84          log.debug("finished");
    85      }
    86      
    87      
    88      public Map output() {
                /* 
    P/P          *  Method: Map output()
                 * 
                 *  Postconditions:
                 *    return_value == null
                 */
    89         return null; 
    90      }
    91      
    92      
    93      public void input(Map input) {
                 /* 
    P/P           *  Method: void input(Map)
                  * 
                  *  Postconditions:
                  *    this.inputs == input
                  *    init'ed(this.inputs)
                  */
    94          this.inputs = input;
    95      }
    96      
    97      
    98      private void warmupFeedCache(List weblogs, String type, String format) {
    99          
                 /* 
    P/P           *  Method: void warmupFeedCache(List, String, String)
                  * 
                  *  Preconditions:
                  *    (soft) log != null
                  *    (soft) org/apache/roller/weblogger/ui/rendering/util/cache/WeblogFeedCache.log != null
                  *    (soft) org/apache/roller/weblogger/ui/rendering/util/cache/WeblogFeedCache.singletonInstance != null
                  *    (soft) init'ed(org/apache/roller/weblogger/ui/rendering/util/cache/WeblogFeedCache.singletonInstance.cacheEnabled)
                  *    (soft) org/apache/roller/weblogger/ui/rendering/util/cache/WeblogFeedCache.singletonInstance.contentCache != null
                  * 
                  *  Presumptions:
                  *    java.lang.System:currentTimeMillis(...)@164 - java.lang.System:currentTimeMillis(...)@107 in -9_223_372_036_854_775..18_446_744_073_709_551
                  *    org.apache.roller.weblogger.ui.rendering.RendererManager:getRenderer(...)@142 != null
                  * 
                  *  Test Vectors:
                  *    weblogs: Inverse{null}, Addr_Set{null}
                  *    java.util.Iterator:hasNext(...)@111: {0}, {1}
                  */
   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 allWeblogs = weblogs.iterator();
   110          String weblogHandle = null;
   111          while(allWeblogs.hasNext()) {
   112              weblogHandle = (String) 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 model = new HashMap();
   125                  Map initData = new HashMap();
   126                  initData.put("request", null);
   127                  initData.put("feedRequest", feedRequest);
   128                  initData.put("weblogRequest", feedRequest);
   129                  
   130                  // Load models for feeds
   131                  String feedModels = WebloggerConfig.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", "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 key = feedCache.generateKey(feedRequest);
   156                  feedCache.put(key, rendererOutput);
   157                  
   158              } catch(Exception 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  }