Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /*!
  * Copyright 2002 - 2013 Webdetails, a Pentaho company.  All rights reserved.
  
  * This software was developed by Webdetails and is provided under the terms
  * of the Mozilla Public License, Version 2.0, or any later version. You may not use
  * this file except in compliance with the license. If you need a copy of the license,
  * please go to  http://mozilla.org/MPL/2.0/. The Initial Developer is Webdetails.
  *
  * Software distributed under the Mozilla Public License is distributed on an "AS IS"
 * basis, WITHOUT WARRANTY OF ANY KIND, either express or  implied. Please refer to
 * the license for the specific language governing your rights and limitations.
 */
 
 package pt.webdetails.cda.cache.scheduler;
 
 import java.util.Date;
 import java.util.List;
 
 
 import  org.hibernate.Session;
 
 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;
 //import pt.webdetails.cda.CdaBoot;
 import  pt.webdetails.cda.CdaEngine;
 import  pt.webdetails.cda.utils.Util;

Author(s):
pdpi
 
 public class CacheScheduleManager
 {
 
   private static final String ENCODING = "UTF-8";
   private static Log logger = LogFactory.getLog(CacheScheduleManager.class);
   public static int DEFAULT_MAX_AGE = 3600;  // 1 hour
   
 //  private static final String ENCODING = "UTF-8";
 
   enum functions
   {
     LIST, CHANGE, RELOAD, DELETE, EXECUTE, IMPORT, 
 //    CACHED, GETDETAILS, CACHEOVERVIEW, REMOVECACHE PERSIST, MONITOR,TEST, DETAILS, 
   }
   
   private static CacheScheduleManager _instance;
 
 
   public static synchronized CacheScheduleManager getInstance()
   {
     if ( == null)
     {
        = new CacheScheduleManager();
     }
     return ;
   }
 
 
   public CacheScheduleManager()
   {
     initialize();
   }
 
 
   public void handleCall(final String method,final String objOutputStream out)
   {
     try
     {
       switch (functions.valueOf(method.toUpperCase()))
       {
         case :
           change(objout);
           break;
         case :
           load(objout);
           break;
        case :
          list(out);
          break;
        case :
          execute(objout);
          break;
        case :
          delete(objout);
          break;
        case :
          importQueries(objout);
          break;
        default:
          .error"Unhandled method " + method );
          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(String objOutputStream outthrows Exception
  {
    Session s = getHibernateSession();
    Long id = Long.decode(obj);
    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 requestParams, OutputStream out)
//  {
//    return; //NYI!
//  }
//  private void persist(IParameterProvider requestParams, OutputStream out) throws Exception
//  {
//
//    Long id = Long.decode(requestParams.getParameter("id").toString());
//    Session s = getHibernateSession();
//    s.beginTransaction();
//
//    UncachedQuery uq = (UncachedQuery) s.load(UncachedQuery.class, id);
//    CachedQuery cq = uq.cacheMe();
//    if (uq != null)
//    {
//      s.delete(s);
//    }
//    JSONObject json = uq.toJSON();
//    out.write(json.toString(2).getBytes(ENCODING));
//    s.flush();
//    s.getTransaction().commit();
//    s.close();
//  }
//  public void called(String file, String id, Boolean 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(String objOutputStream outthrows Exception
  {
    String jsonString = obj;
    JSONTokener jsonTokener = new JSONTokener(jsonString);
    try
    {
      Query query;
      JSONObject json = new JSONObject(jsonTokener);
      if (json.has("cronString"))
      {
        String cronString = json.getString("cronString");
        try
        {
          // test if parses ok
          @SuppressWarnings"unused" )
          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;
        }
        query = new CachedQuery(json);
        if (query != null)
        {
          .add((CachedQueryquery);
          CacheActivator.reschedule();
        }
      }
      else
      {
        query = new UncachedQuery(json);
      }
      Session session = getHibernateSession();
      session.beginTransaction();
      session.save(query);
      session.flush();
      session.getTransaction().commit();
      session.close();
    }
    catch (JSONException jse)
    {
      out.write("".getBytes());
    }
    out.write("{\"status\": \"ok\"}".getBytes());
  }
  private void listOutputStream outthrows PluginHibernateException
  {
    JSONObject list = new JSONObject();
    JSONObject meta = new JSONObject();
    JSONArray queries = new JSONArray();
    Session s = getHibernateSession();
    @SuppressWarnings"unchecked" )
    List<CachedQuerycachedQueries = s.createQuery("from CachedQuery").list();
    for (CachedQuery query : cachedQueries)
    {
      queries.put(query.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(String objOutputStream outthrows Exception
  {
    String jsonString = obj;
    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(String objOutputStream outthrows PluginHibernateException
  {
    Long id = Long.decode(obj);
    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(String objOutputStream outthrows PluginHibernateException
  {
    Long id = Long.decode(obj);
    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();
    @SuppressWarnings"unchecked" )
    List<CachedQuerycachedQueries = s.createQuery( "from " + CachedQuery.class.getSimpleName() ).list(); //TODO: simple name?
    this. = new PriorityBlockingQueue<CachedQuery>(20, new SortByTimeDue());
    for (CachedQuery cq : cachedQueries)
    {
      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)
    {
      .error"PluginHibernateUtil.rebuildSessionFactory"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 = CdaEngine.getInstance().getConfigProperty("pt.webdetails.cda.cache.executeAtStart");
    if (executeAtStart.equals("true"))
    {
//      IPentahoSession session = new StandaloneSession("CDA");
      // run all queries
      Session s = getHibernateSession();
      @SuppressWarnings"unchecked" )
      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
  }
  public Queue<CachedQuerygetQueue()
  {
    return ;
  }
  
  
New to GrepCode? Check out our FAQ X