source/mircoders/global/ProducerEngine.java

   1 /*
   2  * Copyright (C) 2001, 2002 The Mir-coders group
   3  *
   4  * This file is part of Mir.
   5  *
   6  * Mir is free software; you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License as published by
   8  * the Free Software Foundation; either version 2 of the License, or
   9  * (at your option) any later version.
  10  *
  11  * Mir is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  * GNU General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU General Public License
  17  * along with Mir; if not, write to the Free Software
  18  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  19  *
  20  * In addition, as a special exception, The Mir-coders gives permission to link
  21  * the code of this program with  any library licensed under the Apache Software License,
  22  * The Sun (tm) Java Advanced Imaging library (JAI), The Sun JIMI library
  23  * (or with modified versions of the above that use the same license as the above),
  24  * and distribute linked combinations including the two.  You must obey the
  25  * GNU General Public License in all respects for all of the code used other than
  26  * the above mentioned libraries.  If you modify this file, you may extend this
  27  * exception to your version of the file, but you are not obligated to do so.
  28  * If you do not wish to do so, delete this exception statement from your version.
  29  */
  30 package mircoders.global;
  31
  32 import java.io.PrintWriter;
  33 import java.util.HashMap;
  34 import java.util.Iterator;
  35 import java.util.List;
  36 import java.util.Map;
  37 import java.util.Vector;
  38
  39 import mir.log.LoggerToWriterAdapter;
  40 import mir.log.LoggerWrapper;
  41 import mir.producer.Producer;
  42 import mir.producer.ProducerFactory;
  43 import mir.util.*;
  44 import mir.config.*;
  45 import mir.util.StringRoutines;
  46 import multex.Exc;
  47 import multex.Failure;
  48
  49 public class ProducerEngine {
  50 //  private Map producers;
  51   private JobQueue producerJobQueue;
  52   private LoggerWrapper logger;
  53
  54
  55   protected ProducerEngine() {
  56     logger = new LoggerWrapper("Producer");
  57     producerJobQueue = new JobQueue(new LoggerWrapper("Producer.Queue"));
  58   }
  59
  60   public void addJob(String aProducerFactory, String aVerb) {
  61     producerJobQueue.appendJob(new ProducerJob(aProducerFactory, aVerb), aProducerFactory+"."+aVerb);
  62   }
  63
  64   public void cancelJobs(List aJobs) {
  65     producerJobQueue.cancelJobs(aJobs);
  66   };
  67
  68   public void cancelAllJobs() {
  69     producerJobQueue.cancelAllJobs();
  70   };
  71
  72   public void addTask(ProducerTask aTask) {
  73     addJob(aTask.getProducer(), aTask.getVerb());
  74   }
  75
  76   public void addTasks(List aTasks) {
  77     Iterator i = aTasks.iterator();
  78
  79     while (i.hasNext()) {
  80       addTask((ProducerTask) i.next());
  81     }
  82   }
  83
  84   private String convertStatus(JobQueue.JobInfo aJob) {
  85     switch (aJob.getStatus()) {
  86       case JobQueue.STATUS_ABORTED:
  87         return "aborted";
  88       case JobQueue.STATUS_CANCELLED:
  89         return "cancelled";
  90       case JobQueue.STATUS_CREATED:
  91         return "created";
  92       case JobQueue.STATUS_PENDING:
  93         return "pending";
  94       case JobQueue.STATUS_PROCESSED:
  95         return "processed";
  96       case JobQueue.STATUS_PROCESSING:
  97         return "processing";
  98     }
  99     return "unknown";
 100   }
 101
 102   private Map convertJob(JobQueue.JobInfo aJob) {
 103     try {
 104       Map result = new HashMap();
 105       result.put("identifier", aJob.getIdentifier());
 106       result.put("description", aJob.getDescription());
 107       result.put("priority", new Integer(aJob.getPriority()));
 108       result.put("runningtime", new Double( (double) aJob.getRunningTime() / 1000));
 109       result.put("status", convertStatus(aJob));
 110       result.put("lastchange", new GeneratorFormatAdapters.DateFormatAdapter(aJob.getLastChange(), MirPropertiesConfiguration.instance().getString("Mir.DefaultTimezone")));
 111       result.put("finished", new Boolean(
 112           aJob.getStatus() == JobQueue.STATUS_PROCESSED ||
 113           aJob.getStatus() == JobQueue.STATUS_CANCELLED ||
 114           aJob.getStatus() == JobQueue.STATUS_ABORTED));
 115
 116       return result;
 117     }
 118     catch (Throwable t) {
 119       throw new RuntimeException(t.toString());
 120     }
 121   }
 122
 123   private List convertJobInfoList(List aJobInfoList) {
 124     List result = new Vector();
 125
 126     Iterator i = aJobInfoList.iterator();
 127
 128     while (i.hasNext())
 129       result.add(convertJob((JobQueue.JobInfo) i.next()));
 130
 131     return result;
 132   }
 133
 134   public List getQueueStatus() {
 135     return convertJobInfoList(producerJobQueue.getJobsInfo());
 136   }
 137
 138   private class ProducerJob implements JobQueue.Job {
 139     private String factoryName;
 140     private String verb;
 141     private Producer producer;
 142
 143     public ProducerJob(String aFactory, String aVerb) {
 144       factoryName = aFactory;
 145       verb = aVerb;
 146       producer=null;
 147     }
 148
 149     public String getFactoryName() {
 150       return factoryName;
 151     }
 152
 153     public String getVerb() {
 154       return verb;
 155     }
 156
 157     public void abort() {
 158       if (producer!=null) {
 159         producer.abort();
 160       }
 161     }
 162
 163     public boolean run() {
 164       ProducerFactory factory;
 165       long startTime;
 166       long endTime;
 167       boolean result = false;
 168       Map startingMap = new HashMap();
 169
 170       startTime = System.currentTimeMillis();
 171       logger.info("Producing job: "+factoryName+"."+verb);
 172
 173       try {
 174         factory = MirGlobal.localizer().producers().getFactoryForName( factoryName );
 175
 176         if (factory!=null) {
 177           MirGlobal.localizer().producerAssistant().initializeGenerationValueSet(startingMap);
 178
 179           synchronized(factory) {
 180             producer = factory.makeProducer(verb, startingMap);
 181           }
 182           if (producer!=null) {
 183             result = producer.produce(logger);
 184           }
 185         }
 186       }
 187       catch (Throwable t) {
 188         logger.error("Exception occurred while producing " + factoryName + "." + verb + t.getMessage());
 189         t.printStackTrace(new PrintWriter(new LoggerToWriterAdapter(logger, LoggerWrapper.ERROR_MESSAGE)));
 190       }
 191       endTime = System.currentTimeMillis();
 192       logger.info("Done producing job: " + factoryName + "." + verb + ", time elapsed:" + (endTime-startTime) + " ms");
 193
 194       return result;
 195     }
 196
 197     boolean isAborted() {
 198       return false;
 199     }
 200   }
 201
 202   public static class ProducerEngineExc extends Exc {
 203     public ProducerEngineExc(String aMessage) {
 204       super(aMessage);
 205     }
 206   }
 207
 208   public static class ProducerEngineRuntimeExc extends Failure {
 209     public ProducerEngineRuntimeExc(String msg, Exception cause){
 210       super(msg,cause);
 211     }
 212   }
 213
 214   public static class ProducerTask {
 215     private String producer;
 216     private String verb;
 217
 218     public ProducerTask(String aProducer, String aVerb) {
 219       producer = aProducer;
 220       verb = aVerb;
 221     }
 222
 223     public String getVerb() {
 224       return verb;
 225     }
 226
 227     public String getProducer() {
 228       return producer;
 229     }
 230
 231     public static List parseProducerTaskList(String aList) throws ProducerEngineExc {
 232       Iterator i;
 233       List result = new Vector();
 234
 235       i = StringRoutines.splitString(aList, ";").iterator();
 236       while (i.hasNext()) {
 237         String taskExpression = ((String) i.next()).trim();
 238
 239         if (taskExpression.length()>0) {
 240           List parts = StringRoutines.splitString(taskExpression, ".");
 241
 242           if (parts.size() != 2)
 243             throw new ProducerEngineExc("Invalid producer expression: '" + taskExpression + "'");
 244           else
 245             result.add(new ProducerEngine.ProducerTask( (String) parts.get(0), (String) parts.get(1)));
 246         }
 247       }
 248
 249       return result;
 250     }
 251   }
 252 }