MODE-2684 Removes the compile time dependency of modeshape-core towards Apache Tika

The mime type extraction functionality will still function as-is if Tika is present, but now there is also an independent extension-based default which will be used if Tika is not present in the CP at runtime

Author: Horia Chiorean

deploy/jbossas/kit/jboss-wf/org/modeshape/main/module.xml

@@ -37,7 +37,7 @@
         <!-- for the DB binary store -->
         <module name="org.jgroups" slot="${jgroups.module.slot}"/>
 
-        <module name="org.apache.tika" slot="${version.org.apache.tika}" services="import"/>
+        <module name="org.apache.tika" slot="${version.org.apache.tika}" services="import" optional="true"/>
 
         <!-- For naming ... -->
         <module name="javax.api" export="true"/>

extractors/modeshape-extractor-tika/src/test/java/org/modeshape/extractor/tika/TikaTextExtractorTest.java

@@ -41,7 +41,7 @@
 import org.modeshape.common.util.IoUtil;
 import org.modeshape.jcr.InMemoryTestBinary;
 import org.modeshape.jcr.LocalEnvironment;
-import org.modeshape.jcr.mimetype.ContentDetector;
+import org.modeshape.jcr.mimetype.tika.TikaContentDetector;
 import org.modeshape.jcr.mimetype.MimeTypeDetector;
 import org.modeshape.jcr.text.TextExtractorContext;
 import org.modeshape.jcr.text.TextExtractorOutput;
@@ -51,7 +51,7 @@
  */
 public class TikaTextExtractorTest {
 
-    private static final MimeTypeDetector DETECTOR = new ContentDetector(new LocalEnvironment());
+    private static final MimeTypeDetector DETECTOR = new TikaContentDetector(new LocalEnvironment());
     private static final int DEFAULT_TIKA_WRITE_LIMIT = 100000;
     private static final String CHARS = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ";
     private static final Random RANDOM = new Random();

modeshape-jcr/pom.xml

@@ -65,6 +65,7 @@
         <dependency>
             <groupId>org.apache.tika</groupId>
             <artifactId>tika-core</artifactId>
+            <scope>provided</scope>
         </dependency>
         <dependency>
             <groupId>org.apache.tika</groupId>

modeshape-jcr/src/main/java/org/modeshape/jcr/RepositoryConfiguration.java

@@ -54,10 +54,8 @@
 import org.modeshape.jcr.api.index.IndexDefinition.IndexKind;
 import org.modeshape.jcr.api.txn.TransactionManagerLookup;
 import org.modeshape.jcr.index.local.LocalIndexProvider;
-import org.modeshape.jcr.mimetype.ContentDetector;
 import org.modeshape.jcr.mimetype.MimeTypeDetector;
-import org.modeshape.jcr.mimetype.NameOnlyDetector;
-import org.modeshape.jcr.mimetype.NullMimeTypeDetector;
+import org.modeshape.jcr.mimetype.MimeTypeDetectors;
 import org.modeshape.jcr.security.AnonymousProvider;
 import org.modeshape.jcr.security.JaasProvider;
 import org.modeshape.jcr.txn.DefaultTransactionManagerLookup;
@@ -1236,23 +1234,11 @@ public BinaryStore getBinaryStore() throws Exception {
         public String getType() {
             return binaryStorage.getString(FieldName.TYPE, FieldValue.BINARY_STORAGE_TYPE_TRANSIENT);
         }
-        
+    
         protected MimeTypeDetector getMimeTypeDetector(Environment environment) {
-            String mimeTypeDetection = binaryStorage.getString(FieldName.MIMETYPE_DETECTION, FieldValue.MIMETYPE_DETECTION_CONTENT);
-            switch (mimeTypeDetection.toLowerCase()) {
-                case FieldValue.MIMETYPE_DETECTION_CONTENT: {
-                    return new ContentDetector(environment);
-                }
-                case FieldValue.MIMETYPE_DETECTION_NAME: {
-                    return new NameOnlyDetector(environment);
-                }
-                case FieldValue.MIMETYPE_DETECTION_NONE: {
-                    return NullMimeTypeDetector.INSTANCE;
-                }
-                default: {
-                    throw new IllegalArgumentException("Unknown mime-type detector setting: " + mimeTypeDetection);
-                }
-            }
+            String mimeTypeDetection = binaryStorage.getString(FieldName.MIMETYPE_DETECTION,
+                                                               FieldValue.MIMETYPE_DETECTION_CONTENT);
+            return MimeTypeDetectors.createDetectorFor(mimeTypeDetection, environment);
         }
 
         /*

modeshape-jcr/src/main/java/org/modeshape/jcr/mimetype/DefaultMimeTypeDetector.java

@@ -0,0 +1,75 @@
+/*
+ * ModeShape (http://www.modeshape.org)
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *       http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.modeshape.jcr.mimetype;
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.util.HashMap;
+import java.util.Map;
+import javax.jcr.Binary;
+import javax.jcr.RepositoryException;
+import org.modeshape.common.util.StringUtil;
+import org.modeshape.schematic.annotation.ThreadSafe;
+
+/**
+ * A {@link MimeTypeDetector} implementation which uses a properties file to load existing mime types and decides based on the 
+ * name of a binary what the mime type is.
+ * 
+ * @author Horia Chiorean ([email protected])
+ */
+@ThreadSafe
+public final class DefaultMimeTypeDetector implements MimeTypeDetector {
+    
+    private final Map<String, String> mimeTypes;
+    
+    public DefaultMimeTypeDetector() {
+        mimeTypes = loadMimeTypes();
+    }
+    
+    private Map<String, String> loadMimeTypes() {
+        try (BufferedReader reader = 
+                     new BufferedReader(new InputStreamReader(DefaultMimeTypeDetector.class.getResourceAsStream("mimetypes.properties")))) {
+            Map<String, String> result = new HashMap<>();
+            reader.lines().forEach(line -> {
+                String[] parts = line.split("\\s");
+                if (parts.length >= 2) {
+                    String mimeType = parts[0];
+                    for (int i = 1; i < parts.length; i++) {
+                        String extension = parts[i].trim();
+                        if (!StringUtil.isBlank(extension)) {
+                            result.put(extension, mimeType);
+                        }
+                    }
+                }
+            });
+            return result;
+        } catch (IOException e) {
+            throw new RuntimeException(e);
+        }
+    }
+    
+    @Override
+    public String mimeTypeOf(String name, Binary binaryValue) throws RepositoryException, IOException {
+        if (name == null) {
+            return null;
+        }
+        int lastDotIdx = name.lastIndexOf('.');
+        String extension = lastDotIdx > 0 && lastDotIdx + 1 < name.length() ? name.substring(lastDotIdx + 1) : name;
+        return mimeTypes.get(extension);
+    }
+}

modeshape-jcr/src/main/java/org/modeshape/jcr/mimetype/MimeTypeDetectors.java

@@ -0,0 +1,81 @@
+/*
+ * ModeShape (http://www.modeshape.org)
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *       http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.modeshape.jcr.mimetype;
+
+import org.modeshape.common.logging.Logger;
+import org.modeshape.jcr.Environment;
+import org.modeshape.jcr.RepositoryConfiguration;
+import org.modeshape.jcr.mimetype.tika.TikaContentDetector;
+import org.modeshape.jcr.mimetype.tika.TikaNameOnlyDetector;
+
+/**
+ * Class which decides which {@link MimeTypeDetector} implementation to use at runtime
+ * 
+ * @author Horia Chiorean ([email protected])
+ */
+public final class MimeTypeDetectors {
+    
+    private static final Logger LOGGER = Logger.getLogger(MimeTypeDetector.class);
+    private static final boolean TIKA_AVAILABLE; 
+    
+    static {
+        boolean tikaAvailable = true;
+        ClassLoader classLoader = MimeTypeDetector.class.getClassLoader();
+        try {
+            Class.forName("org.apache.tika.detect.DefaultDetector", true, classLoader);
+            Class.forName("org.apache.tika.metadata.Metadata", true, classLoader);
+        } catch (Throwable t) {
+            tikaAvailable = false;
+        }
+        TIKA_AVAILABLE = tikaAvailable;
+        if (LOGGER.isDebugEnabled()) {
+            if (TIKA_AVAILABLE) {
+                LOGGER.debug("Tika is available in the CP; will be used for mimetype detection");
+            } else {
+                LOGGER.debug("Tika is not available in the CP; ModeShape will use a DefaultMimetypeDetector");
+            }
+        }
+    }
+    
+    private MimeTypeDetectors() {
+    }
+    
+    /**
+     * Returns a new mime type detector implementation based on 
+     * the repository {@link org.modeshape.jcr.RepositoryConfiguration.FieldName#MIMETYPE_DETECTION} configuration 
+     *  
+     * @param mimeTypeDetectionConfig a {@code String}, may not be null
+     * @param environment an {@link Environment} instance specific to a repository 
+     * @return a {@link MimeTypeDetector} instance
+     */
+    public static MimeTypeDetector createDetectorFor(String mimeTypeDetectionConfig, Environment environment) {
+        switch (mimeTypeDetectionConfig.toLowerCase()) {
+            case RepositoryConfiguration.FieldValue.MIMETYPE_DETECTION_CONTENT: {
+                return TIKA_AVAILABLE ? new TikaContentDetector(environment) : new DefaultMimeTypeDetector();
+            }
+            case RepositoryConfiguration.FieldValue.MIMETYPE_DETECTION_NAME: {
+                return TIKA_AVAILABLE ? new TikaNameOnlyDetector(environment) : new DefaultMimeTypeDetector();
+            }
+            case RepositoryConfiguration.FieldValue.MIMETYPE_DETECTION_NONE: {
+                return NullMimeTypeDetector.INSTANCE;
+            }
+            default: {
+                throw new IllegalArgumentException("Unknown mime-type detector setting: " + mimeTypeDetectionConfig);
+            }
+        }   
+    }
+}

modeshape-jcr/src/main/java/org/modeshape/jcr/mimetype/ContentDetector.java renamed to modeshape-jcr/src/main/java/org/modeshape/jcr/mimetype/tika/TikaContentDetector.java

@@ -13,7 +13,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-package org.modeshape.jcr.mimetype;
+package org.modeshape.jcr.mimetype.tika;
 
 import java.io.InputStream;
 import org.apache.tika.detect.DefaultDetector;
@@ -27,17 +27,18 @@
 import org.modeshape.common.annotation.ThreadSafe;
 import org.modeshape.jcr.Environment;
 import org.modeshape.jcr.JcrI18n;
+import org.modeshape.jcr.mimetype.MimeTypeDetector;
 
 /**
  * {@link MimeTypeDetector} implementation which uses Apache Tika to determine the mimetype of a given binary, based on the 
  * content (binary) header. This involves reading at least the first X bytes from each binary and is more expensive than 
- * {@link NameOnlyDetector}
+ * {@link TikaNameOnlyDetector}
  *
  * @author Horia Chiorean ([email protected])
  **/
 @Immutable
 @ThreadSafe
-public final class ContentDetector extends TikaMimeTypeDetector {
+public final class TikaContentDetector extends TikaMimeTypeDetector {
 
     private DefaultDetector detector;
 
@@ -46,7 +47,7 @@ public final class ContentDetector extends TikaMimeTypeDetector {
      * 
      * @param environment the {@link Environment} to use for class loading; may not be {@code null}
      */
-    public ContentDetector( Environment environment ) {
+    public TikaContentDetector(Environment environment) {
         super(environment);
     }
 

modeshape-jcr/src/main/java/org/modeshape/jcr/mimetype/TikaMimeTypeDetector.java renamed to modeshape-jcr/src/main/java/org/modeshape/jcr/mimetype/tika/TikaMimeTypeDetector.java

@@ -13,7 +13,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-package org.modeshape.jcr.mimetype;
+package org.modeshape.jcr.mimetype.tika;
 
 import java.io.IOException;
 import java.io.InputStream;
@@ -26,6 +26,7 @@
 import org.modeshape.common.util.SelfClosingInputStream;
 import org.modeshape.common.util.StringUtil;
 import org.modeshape.jcr.Environment;
+import org.modeshape.jcr.mimetype.MimeTypeDetector;
 
 /**
  * A base class for the {@link MimeTypeDetector}s that use the Tika library.

modeshape-jcr/src/main/java/org/modeshape/jcr/mimetype/NameOnlyDetector.java renamed to modeshape-jcr/src/main/java/org/modeshape/jcr/mimetype/tika/TikaNameOnlyDetector.java

@@ -13,7 +13,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-package org.modeshape.jcr.mimetype;
+package org.modeshape.jcr.mimetype.tika;
 
 import java.io.InputStream;
 import org.apache.tika.detect.Detector;
@@ -25,6 +25,7 @@
 import org.modeshape.common.annotation.ThreadSafe;
 import org.modeshape.jcr.Environment;
 import org.modeshape.jcr.JcrI18n;
+import org.modeshape.jcr.mimetype.MimeTypeDetector;
 
 /**
  * {@link MimeTypeDetector} implementation which uses Apache Tika to determine the mimetype of a given binary, based only
@@ -34,7 +35,7 @@
  */
 @Immutable
 @ThreadSafe
-public final class NameOnlyDetector extends TikaMimeTypeDetector {
+public final class TikaNameOnlyDetector extends TikaMimeTypeDetector {
 
     private Detector detector;
 
@@ -43,7 +44,7 @@ public final class NameOnlyDetector extends TikaMimeTypeDetector {
      *
      * @param environment the {@link Environment} to use for class loading; may not be {@code null}
      */
-    public NameOnlyDetector( Environment environment ) {
+    public TikaNameOnlyDetector(Environment environment) {
         super(environment);
     }