Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /*
   * To change this template, choose Tools | Templates
   * and open the template in the editor.
   */
  package pt.webdetails.cda.cache;
  
 import java.util.Date;
 import java.util.List;
 
 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.engine.core.system.StandaloneSession;
 import  org.pentaho.reporting.libraries.base.config.Configuration;
 import  org.quartz.CronExpression;

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";
 
   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 handleCall(IParameterProvider requestParamsOutputStream out)
   {
     String method = requestParams.getParameter("method").toString();
     try
     {
       switch (functions.valueOf(method.toUpperCase()))
       {
         case :
           change(requestParamsout);
           break;
         case :
           load(requestParamsout);
           break;
         case :
           list(requestParamsout);
           break;
         case :
           execute(requestParamsout);
           break;
         case :
           delete(requestParamsout);
           break;
         case :
          importQueries(requestParamsout);
          break;
      }
    }
    catch (Exception e)
    {
      .error(e);
    }
  }
  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(IParameterProvider requestParamsOutputStream out)
  {
    //TODO:
  }
  private void load(IParameterProvider requestParamsOutputStream outthrows Exception
  {
    Session s = getHibernateSession();
    Long id = Long.decode(requestParams.getParameter("id").toString());
    Query q = (Querys.load(Query.classid);
    if (q == null)
    {
      out.write("{}".getBytes());
      .error("Couldn' get Query with id=" + id.toString());
    }
    try
    {
      JSONObject json = q.toJSON();
      out.write(json.toString(2).getBytes());
    }
    catch (Exception e)
    {
      .error(e);
    }
    s.close();
  }
  private void monitor(IParameterProvider requestParamsOutputStream out)
  {
    return//NYI!
  }
  private void persist(IParameterProvider requestParamsOutputStream outthrows Exception
  {
    Long id = Long.decode(requestParams.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();
    out.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);
     */
  }
  private void change(IParameterProvider requestParamsOutputStream outthrows Exception
  {
    String jsonString = requestParams.getParameter("object").toString();
    JSONTokener jsonTokener = new JSONTokener(jsonString);
    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 + "\"");
          out.write("{\"status\": \"error\", \"message\": \"failed to parse Cron String\"}".getBytes());
          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)
    {
      out.write("".getBytes());
    }
    out.write("{\"status\": \"ok\"}".getBytes());
  }
  private void list(IParameterProvider requestParamsOutputStream outthrows 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
    {
      out.write(list.toString(2).getBytes());
    }
    catch (Exception e)
    {
      .error(e);
    }
    finally
    {
      s.close();
    }
  }
  private void importQueries(IParameterProvider requestParamsOutputStream outthrows Exception
  {
    String jsonString = requestParams.getParameter("object").toString();
    JSONTokener jsonTokener = new JSONTokener(jsonString);
    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));
      out.write("".getBytes());
    }
  }
  private void execute(IParameterProvider requestParamsOutputStream outthrows PluginHibernateException
  {
    Long id = Long.decode(requestParams.getParameter("id").toString());
    Session s = getHibernateSession();
    CachedQuery q = (CachedQuerys.load(CachedQuery.classid);
    if (q == null)
    {
      // Query doesn't exist or is not set for auto-caching
      return;
    }
    try
    {
      q.execute();
      q.updateNext();
      CacheActivator.reschedule();
      out.write("{\"status\": \"ok\"}".getBytes());
    }
    catch (Exception ex)
    {
      .error(ex);
      try
      {
        out.write("{\"status\": \"error\"}".getBytes());
      }
      catch (Exception ex1)
      {
        .error(ex1);
      }
    }
    finally
    {
      s.beginTransaction();
      s.update(q);
      s.flush();
      s.getTransaction().commit();
      s.close();
    }
  }
  private void delete(IParameterProvider requestParamsOutputStream outthrows PluginHibernateException
  {
    Long id = Long.decode(requestParams.getParameter("id").toString());
    Session s = getHibernateSession();
    s.beginTransaction();
    Query q = (Querys.load(Query.classid);
    s.delete(q);
    for (CachedQuery cq : )
    {
      if (cq.getId() == id)
      {
        .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
  {
    // Get hbm file
    IPluginResourceLoader resLoader = PentahoSystem.get(IPluginResourceLoader.classnull);
    InputStream in = resLoader.getResourceAsStream(CdaContentGenerator.class"cachemanager.hbm.xml");
    // Close session and rebuild
    PluginHibernateUtil.closeSession();
    org.hibernate.cfg.Configuration configuration = PluginHibernateUtil.getConfiguration();
    //if (configuration.getClassMapping(CachedQuery.class.getCanonicalName()) == null)
    //{
    configuration.addInputStream(in);
    try
    {
      PluginHibernateUtil.rebuildSessionFactory();
    }
    catch (Exception e)
    {
      return;
    }
    //}
  }


  
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 ;
  }
  
  
New to GrepCode? Check out our FAQ X