Merged V2.1 to HEAD

6455: OpenOffice transformer and extractor register regardless of the initial connection state.
   6456: Fix for WCM-636 (Clicking OK twice while deleting web project results in exception)
   6457: Updated installers and associated config
   6458: AR-1669 Add getQnamePath to Javascript
   6459: Fix for AWC-1456 - Word and Excel documents were being stored as octet streams rather than their correct mimetype
   6460: Reverse order of reject & approve transitions, so that approve appears first in list of ui actions.
   6461: Removed Process.exe (often detected as a virus) and updated config wizard.
   6462: Switch to synchronous indexing for AVM by default
   6463: Better support to query the state of AVM indexes
   6464: Added Office 2007 document mimetypes and icons
   6465: Added Office 2007 icons without the typo this time


git-svn-id: https://svn.alfresco.com/repos/alfresco-enterprise/alfresco/HEAD/root@6736 c4b6b30b-aa2e-2d43-bbcb-ca4b014f7261

source/java/org/alfresco/repo/content/metadata/MetadataExtracterRegistry.java

@@ -49,7 +49,7 @@ public class MetadataExtracterRegistry
     private static final Log logger = LogFactory.getLog(MetadataExtracterRegistry.class);
 
     private List<MetadataExtracter> extracters;
-    private Map<String, MetadataExtracter> extracterCache;
+    private Map<String, List<MetadataExtracter>> extracterCache;
 
     /** Controls read access to the cache */
     private Lock extracterCacheReadLock;
@@ -60,7 +60,7 @@ public class MetadataExtracterRegistry
     {
         // initialise lists
         extracters = new ArrayList<MetadataExtracter>(10);
-        extracterCache = new HashMap<String, MetadataExtracter>(17);
+        extracterCache = new HashMap<String, List<MetadataExtracter>>(17);
 
         // create lock objects for access to the cache
         ReadWriteLock extractionCacheLock = new ReentrantReadWriteLock();
@@ -104,7 +104,7 @@ public class MetadataExtracterRegistry
      */
     public MetadataExtracter getExtracter(String sourceMimetype)
     {
-        MetadataExtracter extracter = null;
+        List<MetadataExtracter> extractors = null;
         extracterCacheReadLock.lock();
         try
         {
@@ -112,7 +112,7 @@ public class MetadataExtracterRegistry
             {
                 // the translation has been requested before
                 // it might have been null
-                return extracterCache.get(sourceMimetype);
+                extractors = extracterCache.get(sourceMimetype);
             }
         }
         finally
@@ -120,44 +120,59 @@ public class MetadataExtracterRegistry
             extracterCacheReadLock.unlock();
         }
 
-        // the translation has not been requested before
-        // get a write lock on the cache
-        // no double check done as it is not an expensive task
-        extracterCacheWriteLock.lock();
-        try
+        if (extractors == null)
         {
-            // find the most suitable transformer - may be empty list
-            extracter = findBestExtracter(sourceMimetype);
-            // store the result even if it is null
-            extracterCache.put(sourceMimetype, extracter);
-            return extracter;
+            // No request has been made before
+            // Get a write lock on the cache
+            // No double check done as it is not an expensive task
+            extracterCacheWriteLock.lock();
+            try
+            {
+                // find the most suitable transformer - may be empty list
+                extractors = findBestExtracters(sourceMimetype);
+                // store the result even if it is null
+                extracterCache.put(sourceMimetype, extractors);
+            }
+            finally
+            {
+                extracterCacheWriteLock.unlock();
+            }
         }
-        finally
+        
+        // We have the list of extractors that supposedly work (as registered).
+        // Take the first one that still claims to work
+        MetadataExtracter liveExtractor = null;
+        for (MetadataExtracter extractor : extractors)
         {
-            extracterCacheWriteLock.unlock();
+            // An extractor may dynamically become unavailable 
+            if (!extractor.isSupported(sourceMimetype))
+            {
+                continue;
+            }
+            liveExtractor = extractor;
         }
+        return liveExtractor;
     }
 
     /**
-     * @param sourceMimetype The MIME type under examination
-     * @return The fastest of the most reliable extracters in <code>extracters</code>
-     *      for the given MIME type, or null if none is available.
+     * @param       sourceMimetype The MIME type under examination
+     * @return      Returns a set of extractors that will work for the given mimetype
      */
-    private MetadataExtracter findBestExtracter(String sourceMimetype)
+    private List<MetadataExtracter> findBestExtracters(String sourceMimetype)
     {
-        logger.debug("Finding best extracter for " + sourceMimetype);
+        logger.debug("Finding extractors for " + sourceMimetype);
 
-        MetadataExtracter bestExtracter = null;
+        List<MetadataExtracter> extractors = new ArrayList<MetadataExtracter>(1);
 
-        for (MetadataExtracter ext : extracters)
+        for (MetadataExtracter extractor : extracters)
         {
-            if (!ext.isSupported(sourceMimetype))
+            if (!extractor.isSupported(sourceMimetype))
             {
                 // extraction not achievable
                 continue;
             }
-            bestExtracter = ext;
+            extractors.add(extractor);
         }
-        return bestExtracter;
+        return extractors;
     }
 }