Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /* This Source Code Form is subject to the terms of the Mozilla Public
   * License, v. 2.0. If a copy of the MPL was not distributed with this file,
   * You can obtain one at http://mozilla.org/MPL/2.0/. */
  
  package pt.webdetails.cda.cache;
  
 import java.util.Date;
 import java.util.List;
 import  javax.servlet.http.HttpServletRequest;
 import  javax.servlet.http.HttpServletResponse;
 import  org.apache.commons.io.IOUtils;
 
 import  org.apache.commons.logging.Log;
 import  org.apache.commons.logging.LogFactory;
 
 import  org.hibernate.Session;
 import  org.pentaho.platform.api.engine.IParameterProvider;
 import  org.pentaho.platform.api.engine.IPluginResourceLoader;
 import  org.pentaho.platform.engine.core.system.PentahoSystem;
 
 import  org.json.JSONArray;
 import  org.json.JSONException;
 import  org.json.JSONObject;
 import  org.json.JSONTokener;
 import  org.pentaho.platform.api.engine.IPentahoSession;
 import  org.pentaho.platform.api.engine.IPluginManager;
 import  org.pentaho.platform.engine.core.system.StandaloneSession;
 import  org.pentaho.reporting.libraries.base.config.Configuration;
 import  org.quartz.CronExpression;
 import  pt.webdetails.cpf.repository.RepositoryAccess;

Author(s):
pdpi
 
 public class CacheScheduleManager
 {
 
   private static final String ENCODING = "UTF-8";
   static Log logger = LogFactory.getLog(CacheScheduleManager.class);
   final String PLUGIN_PATH = PentahoSystem.getApplicationContext().getSolutionPath("system/" + .);
   public static int DEFAULT_MAX_AGE = 3600;  // 1 hour
   
 //  private static final String ENCODING = "UTF-8";
 
   public enum functions
   {
     LIST, CHANGE, RELOAD, DELETE, PERSIST, MONITOR, DETAILS, TEST, EXECUTE, IMPORT, 
     CACHED, GETDETAILS, CACHEOVERVIEW, REMOVECACHE
   }
   
   private static CacheScheduleManager _instance;
 
 
   public static synchronized CacheScheduleManager getInstance()
   {
     if ( == null)
     {
        = new CacheScheduleManager();
     }
     return ;
   }
 
 
   public CacheScheduleManager()
   {
     initialize();
   }
 
   public void register(Query query)
   {
   }
 
 
   private void initialize()
   {
     try
     {
       initHibernate();
       initQueue();
     }
     catch (PluginHibernateException ex)
     {
       .warn("Found PluginHibernateException while initializing CacheScheduleManager " + Util.getExceptionDescription(ex));
     }
   }
  
  public void render(HttpServletRequest request, HttpServletResponse response)
  {
    //TODO:
  }
  public void load(String idOutputStream responsethrows Exception
  {
    Session s = getHibernateSession();
    Long idLong = Long.decode(id);
    Query q = (Querys.load(Query.classidLong);
    if (q == null)
    {
      writeOut(response"{}");
      .error("Couldn' get Query with id=" + idLong.toString());
    }
    try
    {
      JSONObject json = q.toJSON();
      writeOut(responsejson.toString(2));
    }
    catch (Exception e)
    {
      .error(e);
    }
    s.close();
  }
  private void monitor(HttpServletRequest request, HttpServletResponse response)
  {
    return//NYI!
  }
  private void persist(HttpServletRequest request, HttpServletResponse responsethrows Exception
  {
    Long id = Long.decode(request.getParameter("id").toString());
    Session s = getHibernateSession();
    s.beginTransaction();
    UncachedQuery uq = (UncachedQuerys.load(UncachedQuery.classid);
    CachedQuery cq = uq.cacheMe();
    if (uq != null)
    {
      s.delete(s);
    }
    JSONObject json = uq.toJSON();
    response.getOutputStream().write(json.toString(2).getBytes());
    s.flush();
    s.getTransaction().commit();
    s.close();
  }
  public void called(String fileString idBoolean hit)
  {
    return//not implemented yet!
    /*
    Session s = getSession();
    Query q;
    List l = s.createQuery("from CachedQuery where cdaFile=? and dataAccessId=?") //
    .setString(0, file) //
    .setString(1, id) //
    .list();
    
    if (l.size() == 0)
    {
    // No results, create a new (uncached) query object.
    q = new UncachedQuery();
    }
    else if (l.size() == 1)
    {
    q = (Query) l.get(0);
    }
    else
    {
    q = (Query) l.get(0);
    // Find correct params set
    //
    }
    q.registerRequest(hit);
    s.save(q);
     */
  }
  public void change(String objectOutputStream responsethrows Exception
  {
    JSONTokener jsonTokener = new JSONTokener(object);
    try
    {
      Query q;
      JSONObject json = new JSONObject(jsonTokener);
      if (json.has("cronString"))
      {
        String cronString = json.getString("cronString");
        try
        {
          CronExpression ce = new CronExpression(cronString);
        }
        catch (Exception e)
        {
          .error("Failed to parse Cron string \"" + cronString + "\"");
          writeOut(response"{\"status\": \"error\", \"message\": \"failed to parse Cron String\"}");
          return;
        }
        q = new CachedQuery(json);
        if (q != null)
        {
          .add((CachedQueryq);
          CacheActivator.reschedule();
        }
      }
      else
      {
        q = new UncachedQuery(json);
      }
      Session s = getHibernateSession();
      s.beginTransaction();
      s.save(q);
      s.flush();
      s.getTransaction().commit();
      s.close();
    }
    catch (JSONException jse)
    {
      writeOut(response"");
      
    }
    writeOut(response"{\"status\": \"ok\"}");
  }
  public void list(OutputStream responsethrows PluginHibernateException
  {
    JSONObject list = new JSONObject();
    JSONObject meta = new JSONObject();
    JSONArray queries = new JSONArray();
    Session s = getHibernateSession();
    List l = s.createQuery("from CachedQuery").list();
    for (Object o : l)
    {
      queries.put(((Queryo).toJSON());
    }
    try
    {
      meta.put("nextExecution".size() > 0 ? .peek().getNextExecution().getTime() : 0);
      list.put("queries"queries);
      list.put("meta"meta);
    }
    catch (Exception e)
    {
      .error(e);
    }
    try
    {
      writeOut(responselist.toString(2));
    }
    catch (Exception e)
    {
      .error(e);
    }
    finally
    {
      s.close();
    }
  }
  public void importQueries(String objectOutputStream responsethrows Exception
  {
    JSONTokener jsonTokener = new JSONTokener(object);
    try
    {
      Query q;
      JSONObject json;
      Session s = getHibernateSession();
      s.beginTransaction();
      JSONObject root = new JSONObject(jsonTokener);
      JSONArray ja = root.getJSONArray("queries");
      for (int i = 0; i < ja.length(); i++)
      {
        json = ja.getJSONObject(i);
        if (json.has("cronString"))
        {
          q = new CachedQuery(json);
          .add((CachedQueryq);
          CacheActivator.reschedule();
        }
        else
        {
          q = new UncachedQuery(json);
        }
        s.save(q);
      }
      s.flush();
      s.getTransaction().commit();
      s.close();
    }
    catch (JSONException jse)
    {
      .error("Error importing queries: " + Util.getExceptionDescription(jse));
      writeOut(response"");
    }
  }
  public void execute(String idOutputStream responsethrows PluginHibernateException
  {
    Long idLong = Long.decode(id);
    Session s = getHibernateSession();
    CachedQuery q = (CachedQuerys.load(CachedQuery.classidLong);
    if (q == null)
    {
      // Query doesn't exist or is not set for auto-caching
      return;
    }
    try
    {
      q.execute();
      q.updateNext();
      CacheActivator.reschedule();
      writeOut(response"{\"status\": \"ok\"}");
    }
    catch (Exception ex)
    {
      .error(ex);
      try
      {
        writeOut(response"{\"status\": \"error\"}");
      }
      catch (Exception ex1)
      {
        .error(ex1);
      }
    }
    finally
    {
      s.beginTransaction();
      s.update(q);
      s.flush();
      s.getTransaction().commit();
      s.close();
    }
  }
  public void delete(String idthrows PluginHibernateException
  {
    Long idLong = Long.decode(id);
    Session s = getHibernateSession();
    s.beginTransaction();
    Query q = (Querys.load(Query.classidLong);
    s.delete(q);
    for (CachedQuery cq : )
    {
      if (cq.getId() == idLong)
      {
        .remove(cq);
      }
    }
    s.flush();
    s.getTransaction().commit();
    s.close();
  }
  private Session getHibernateSession() throws PluginHibernateException
  {
    return PluginHibernateUtil.getSession();
  }
  class SortByTimeDue implements Comparator<CachedQuery>
  {
    public int compare(CachedQuery o1CachedQuery o2)
    {
      return (int) (o1.getNextExecution().getTime() - o2.getNextExecution().getTime());
    }
  }
  private void initQueue() throws PluginHibernateException
  {
    Session s = getHibernateSession();
    s.beginTransaction();
    List l = s.createQuery("from CachedQuery").list();
    this. = new PriorityQueue<CachedQuery>(20, new SortByTimeDue());
    for (Object o : l)
    {
      CachedQuery cq = (CachedQueryo;
      if (cq.getLastExecuted() == null)
      {
        cq.setLastExecuted(new Date(0L));
      }
      Date nextExecution;
      try
      {
        nextExecution = new CronExpression(cq.getCronString()).getNextValidTimeAfter(new Date());
      }
      catch (ParseException ex)
      {
        nextExecution = new Date(0);
        .error("Failed to schedule " + cq.toString());
      }
      cq.setNextExecution(nextExecution);
      this..add(cq);
      s.save(cq);
    }
    s.flush();
    s.getTransaction().commit();
    s.close();
  }
  public static void initHibernate() throws PluginHibernateException
  {
    PluginHibernateUtil.initialize();
    // Get hbm file
    IPluginResourceLoader resLoader = PentahoSystem.get(IPluginResourceLoader.classnull);
    InputStream in = resLoader.getResourceAsStream(CacheScheduleManager.class"cachemanager.hbm.xml");
    
/*    IPluginResourceLoader resLoader = PentahoSystem.get(IPluginResourceLoader.class, null);
    IPluginManager pluginManager = PentahoSystem.get(IPluginManager.class);
    ClassLoader classLoader = pluginManager.getClassLoader(CdaContentGenerator.PLUGIN_NAME);
    InputStream inputStream = resLoader.getResourceAsStream(classLoader, "cachemanager.hbm.xml");
    
    StringWriter writer = new StringWriter();
    try {
      IOUtils.copy(inputStream, writer, "UTF-8");
    } catch (IOException ex){
      return;
    }
    
    String content = writer.toString();
  */  
    // Close session and rebuild
    PluginHibernateUtil.closeSession();
    org.hibernate.cfg.Configuration configuration = PluginHibernateUtil.getConfiguration();
    configuration.addInputStream(in);
  //  configuration.addFile(RepositoryAccess.getSystemDir() + "/cda/cachemanager.hbm.xml");
    PluginHibernateUtil.rebuildSessionFactory();
  }


  
Initializes the CacheScheduleManager from a cold boot. Ensures all essential cached queries are populated at boot time, and sets up the first query timer.
  public void coldInit() throws PluginHibernateException
  {
    Configuration config = CdaBoot.getInstance().getGlobalConfig();
    String executeAtStart = config.getConfigProperty("pt.webdetails.cda.cache.executeAtStart");
    if (executeAtStart.equals("true"))
    {
      IPentahoSession session = new StandaloneSession("CDA");
      // run all queries
      Session s = getHibernateSession();
      List<CachedQuerycachedQueries = s.createQuery("from CachedQuery").list();
      for (CachedQuery cq : cachedQueries)
      {
        try
        {
          cq.execute();
        }
        catch (Exception ex)
        {
          .error("Error executing " + cq.toString() + ":" + ex.toString());
        }
      }
      s.close();
    }
    CacheActivator.reschedule();
    CacheActivator.rescheduleBackup();
  }


  
Re-initializes the CacheScheduleManager after. Should be called after a plug-in installation at runtime, to ensure the query queue is kept consistent
  public void hotInit()
  {
    return//NYI
  }
  {
    return ;
  }
  
  
  protected void writeOut(OutputStream outString contentsthrows IOException {
    IOUtils.write(contentsoutgetEncoding());
    out.flush();
  }
  
  protected static String getEncoding() { return ; }
  
New to GrepCode? Check out our FAQ X