1.1 restoration

[mir.git] / source / mircoders / global / ProducerEngine.java

diff --git a/source/mircoders/global/ProducerEngine.java b/source/mircoders/global/ProducerEngine.java
index 5477bae..33a6267 100755 (executable)
--- a/source/mircoders/global/ProducerEngine.java
+++ b/source/mircoders/global/ProducerEngine.java
@@ -30,57 +30,114 @@
 package mircoders.global;
 
 import java.io.PrintWriter;
+import java.util.ArrayList;
 import java.util.HashMap;
 import java.util.Iterator;
 import java.util.List;
 import java.util.Map;
 import java.util.Vector;
 
+import mir.config.MirPropertiesConfiguration;
 import mir.log.LoggerToWriterAdapter;
 import mir.log.LoggerWrapper;
 import mir.producer.Producer;
 import mir.producer.ProducerFactory;
-import mir.util.*;
-import mir.config.*;
+import mir.util.GeneratorFormatAdapters;
 import mir.util.StringRoutines;
-import multex.Exc;
-import multex.Failure;
 
 public class ProducerEngine {
-//  private Map producers;
   private JobQueue producerJobQueue;
   private LoggerWrapper logger;
-
+  private Map nameToFactory;
+  private List factories;
 
   protected ProducerEngine() {
     logger = new LoggerWrapper("Producer");
     producerJobQueue = new JobQueue(new LoggerWrapper("Producer.Queue"));
+
+    factories = new ArrayList();
+    nameToFactory = new HashMap();
+
+    try {
+      reloadConfiguration();
+    }
+    catch (Throwable t) {
+    }
+  }
+
+  /**
+   * Reloads the producer configuration
+   */
+  public void reloadConfiguration()  throws MirGlobalExc, MirGlobalFailure {
+    try {
+      factories = MirGlobal.localizer().producers().loadFactories();
+
+      synchronized (nameToFactory) {
+        nameToFactory.clear();
+
+        Iterator i = factories.iterator();
+        while (i.hasNext()) {
+          ProducerFactory factory = (ProducerFactory) i.next();
+          nameToFactory.put(factory.getName(), factory);
+        }
+      }
+    }
+    catch (Throwable t) {
+      throw new MirGlobalFailure(t);
+    }
+  }
+
+  /**
+   * Looks up a producer factory by name
+   */
+  private ProducerFactory getFactoryForName(String aName) {
+    synchronized (nameToFactory) {
+      return (ProducerFactory) nameToFactory.get(aName);
+    }
   }
 
-  public void addJob(String aProducerFactory, String aVerb) {
-    producerJobQueue.appendJob(new ProducerJob(aProducerFactory, aVerb), aProducerFactory+"."+aVerb);
+  /**
+   * Returns all factories
+   */
+  public List getFactories() {
+    return factories;
   }
+  /**
+   * Adds a producer job to the queue
+   */
+  public void addJob(String aProducerFactory, String aVerb) throws MirGlobalExc, MirGlobalFailure {
+    ProducerFactory factory;
+
+    factory = getFactoryForName( aProducerFactory );
+
+    if (factory==null)
+      throw new MirGlobalExc("Unknown producer: " + aProducerFactory);
+
+    if (!factory.allowVerb(aVerb))
+      throw new MirGlobalExc("illegal producer/verb combination: " + aProducerFactory+"::"+aVerb);
 
+    producerJobQueue.appendJob(
+        new ProducerJob(aProducerFactory, aVerb), aProducerFactory+"."+aVerb);
+  }
+
+  /**
+   * Cancels a list of jobs by job identifier
+   */
   public void cancelJobs(List aJobs) {
     producerJobQueue.cancelJobs(aJobs);
   };
 
+  /**
+   * Cancels all jobs in the queue
+   */
   public void cancelAllJobs() {
     producerJobQueue.cancelAllJobs();
   };
 
-  public void addTask(ProducerTask aTask) {
+  public void addTask(ProducerTask aTask) throws MirGlobalExc, MirGlobalFailure {
     addJob(aTask.getProducer(), aTask.getVerb());
   }
 
-  public void addTasks(List aTasks) {
-    Iterator i = aTasks.iterator();
-
-    while (i.hasNext()) {
-      addTask((ProducerTask) i.next());
-    }
-  }
-
   private String convertStatus(JobQueue.JobInfo aJob) {
     switch (aJob.getStatus()) {
       case JobQueue.STATUS_ABORTED:
@@ -166,12 +223,17 @@ public class ProducerEngine {
       long endTime;
       boolean result = false;
       Map startingMap = new HashMap();
+      Map mirMap = new HashMap();
+      mirMap.put("producer", factoryName);
+      mirMap.put("verb", verb);
+
+      startingMap.put("Mir", mirMap);
 
       startTime = System.currentTimeMillis();
       logger.info("Producing job: "+factoryName+"."+verb);
 
       try {
-        factory = MirGlobal.localizer().producers().getFactoryForName( factoryName );
+        factory = getFactoryForName(factoryName);
 
         if (factory!=null) {
           MirGlobal.localizer().producerAssistant().initializeGenerationValueSet(startingMap);
@@ -199,18 +261,6 @@ public class ProducerEngine {
     }
   }
 
-  public static class ProducerEngineExc extends Exc {
-    public ProducerEngineExc(String aMessage) {
-      super(aMessage);
-    }
-  }
-
-  public static class ProducerEngineRuntimeExc extends Failure {
-    public ProducerEngineRuntimeExc(String msg, Exception cause){
-      super(msg,cause);
-    }
-  }
-
   public static class ProducerTask {
     private String producer;
     private String verb;
@@ -228,7 +278,7 @@ public class ProducerEngine {
       return producer;
     }
 
-    public static List parseProducerTaskList(String aList) throws ProducerEngineExc {
+    public static List parseProducerTaskList(String aList) throws MirGlobalExc {
       Iterator i;
       List result = new Vector();
 
@@ -240,7 +290,7 @@ public class ProducerEngine {
           List parts = StringRoutines.splitString(taskExpression, ".");
 
           if (parts.size() != 2)
-            throw new ProducerEngineExc("Invalid producer expression: '" + taskExpression + "'");
+            throw new MirGlobalExc("Invalid producer expression: '" + taskExpression + "'");
           else
             result.add(new ProducerEngine.ProducerTask( (String) parts.get(0), (String) parts.get(1)));
         }