TIKA-4583: Refactor ConfigStore to use PF4J plugin system

- ConfigStore now extends TikaExtension interface
- ConfigStoreFactory converted to PF4J-based factory interface
- Created IgniteConfigStoreFactory with @extension annotation
- IgniteConfigStore now loaded via plugin discovery
- Updated InMemoryConfigStore and LoggingConfigStore with getExtensionConfig()
- TikaGrpcServerImpl now uses plugin manager to load ConfigStore

Benefits:
- Proper plugin architecture following Tika patterns
- ConfigStore implementations auto-discovered via PF4J
- No hard-coded class names or reflection needed
- Consistent with Fetcher/Emitter factory pattern

Author: Nicholas DiPiazza

tika-grpc/src/main/java/org/apache/tika/pipes/grpc/TikaGrpcServerImpl.java

@@ -109,10 +109,12 @@ class TikaGrpcServerImpl extends TikaGrpc.TikaImplBase {
             pluginManager = new org.pf4j.DefaultPluginManager();
         }
 
-        // Create ConfigStore based on PipesConfig setting
+        // Create ConfigStore based on PipesConfig setting using plugin system
         org.apache.tika.pipes.core.config.ConfigStore configStore = 
             org.apache.tika.pipes.core.config.ConfigStoreFactory.createConfigStore(
-                pipesConfig.getConfigStoreType());
+                pluginManager, 
+                pipesConfig.getConfigStoreType(),
+                null);
 
         fetcherManager = FetcherManager.load(pluginManager, tikaJsonConfig, true, configStore);
     }

tika-pipes/tika-ignite-config-store/src/main/java/org/apache/tika/pipes/ignite/IgniteConfigStore.java

@@ -56,6 +56,7 @@ public class IgniteConfigStore implements ConfigStore {
     private CacheMode cacheMode = CacheMode.REPLICATED;
     private String igniteInstanceName = DEFAULT_INSTANCE_NAME;
     private boolean autoClose = true;
+    private ExtensionConfig extensionConfig;
 
     /**
      * Default constructor.
@@ -64,6 +65,17 @@ public class IgniteConfigStore implements ConfigStore {
     public IgniteConfigStore() {
     }
 
+    /**
+     * Constructor with ExtensionConfig (used by factory).
+     *
+     * @param extensionConfig the extension configuration
+     */
+    public IgniteConfigStore(ExtensionConfig extensionConfig) {
+        this.extensionConfig = extensionConfig;
+        // TODO: Parse configuration from extensionConfig.json() if needed
+        // For now, using defaults
+    }
+
     /**
      * Constructor with custom cache name.
      *
@@ -73,6 +85,11 @@ public IgniteConfigStore(String cacheName) {
         this.cacheName = cacheName;
     }
 
+    @Override
+    public ExtensionConfig getExtensionConfig() {
+        return extensionConfig;
+    }
+
     @Override
     public void init() throws Exception {
         if (ignite != null) {

tika-pipes/tika-ignite-config-store/src/main/java/org/apache/tika/pipes/ignite/IgniteConfigStoreFactory.java

@@ -0,0 +1,46 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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.apache.tika.pipes.ignite;
+
+import java.io.IOException;
+
+import org.pf4j.Extension;
+
+import org.apache.tika.exception.TikaConfigException;
+import org.apache.tika.pipes.core.config.ConfigStore;
+import org.apache.tika.pipes.core.config.ConfigStoreFactory;
+import org.apache.tika.plugins.ExtensionConfig;
+
+/**
+ * Factory for creating Ignite-based ConfigStore instances.
+ */
+@Extension
+public class IgniteConfigStoreFactory implements ConfigStoreFactory {
+
+    private static final String NAME = "ignite";
+
+    @Override
+    public String getName() {
+        return NAME;
+    }
+
+    @Override
+    public ConfigStore buildExtension(ExtensionConfig extensionConfig) 
+            throws IOException, TikaConfigException {
+        return new IgniteConfigStore(extensionConfig);
+    }
+}

tika-pipes/tika-pipes-core/src/main/java/org/apache/tika/pipes/core/config/ConfigStore.java

@@ -19,6 +19,7 @@
 import java.util.Set;
 
 import org.apache.tika.plugins.ExtensionConfig;
+import org.apache.tika.plugins.TikaExtension;
 
 /**
  * Interface for storing and retrieving component configurations.
@@ -32,7 +33,7 @@
  * <b>Performance considerations:</b> The {@link #keySet()} method should be an inexpensive operation
  * as it may be called in error message generation and other scenarios where performance matters.
  */
-public interface ConfigStore {
+public interface ConfigStore extends TikaExtension {
 
     /**
      * Initializes the configuration store.

tika-pipes/tika-pipes-core/src/main/java/org/apache/tika/pipes/core/config/ConfigStoreFactory.java

@@ -16,56 +16,87 @@
  */
 package org.apache.tika.pipes.core.config;
 
+import java.io.IOException;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+import org.pf4j.PluginManager;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
+import org.apache.tika.exception.TikaConfigException;
+import org.apache.tika.plugins.ExtensionConfig;
+import org.apache.tika.plugins.TikaExtensionFactory;
+
 /**
- * Factory for creating ConfigStore instances based on configuration.
+ * Factory interface for creating ConfigStore instances.
+ * Implementations should be annotated with @Extension to be discovered by PF4J.
  */
-public class ConfigStoreFactory {
-    
-    private static final Logger LOG = LoggerFactory.getLogger(ConfigStoreFactory.class);
+public interface ConfigStoreFactory extends TikaExtensionFactory<ConfigStore> {
 
+    Logger LOG = LoggerFactory.getLogger(ConfigStoreFactory.class);
+
     /**
-     * Creates a ConfigStore instance based on the specified type.
+     * Creates a ConfigStore instance based on configuration.
      *
-     * @param type the type of ConfigStore to create ("memory", "ignite", or a fully qualified class name)
+     * @param pluginManager the plugin manager
+     * @param configStoreType the type of ConfigStore to create
+     * @param extensionConfig optional configuration for the store
      * @return a ConfigStore instance
-     * @throws RuntimeException if the store type is invalid or cannot be instantiated
+     * @throws TikaConfigException if the store cannot be created
      */
-    public static ConfigStore createConfigStore(String type) {
-        if (type == null || type.isEmpty() || "memory".equalsIgnoreCase(type)) {
+    static ConfigStore createConfigStore(PluginManager pluginManager, String configStoreType, 
+                                         ExtensionConfig extensionConfig) 
+            throws TikaConfigException {
+        if (configStoreType == null || configStoreType.isEmpty() || "memory".equalsIgnoreCase(configStoreType)) {
             LOG.info("Creating InMemoryConfigStore");
-            return new InMemoryConfigStore();
+            InMemoryConfigStore store = new InMemoryConfigStore();
+            if (extensionConfig != null) {
+                store.setExtensionConfig(extensionConfig);
+            }
+            return store;
+        }
+        
+        // Load all ConfigStoreFactory extensions
+        List<ConfigStoreFactory> factories = pluginManager.getExtensions(ConfigStoreFactory.class);
+        Map<String, ConfigStoreFactory> factoryMap = new HashMap<>();
+        for (ConfigStoreFactory factory : factories) {
+            factoryMap.put(factory.getName(), factory);
         }
 
-        if ("ignite".equalsIgnoreCase(type)) {
+        // Try to find factory by name
+        ConfigStoreFactory factory = factoryMap.get(configStoreType);
+        if (factory != null) {
+            LOG.info("Creating ConfigStore using factory: {}", factory.getName());
             try {
-                LOG.info("Creating IgniteConfigStore");
-                Class<?> igniteClass = Class.forName("org.apache.tika.pipes.ignite.IgniteConfigStore");
-                return (ConfigStore) igniteClass.getDeclaredConstructor().newInstance();
-            } catch (ClassNotFoundException e) {
-                throw new RuntimeException(
-                    "IgniteConfigStore not found. Add tika-ignite-config-store dependency to use Ignite store.", e);
-            } catch (Exception e) {
-                throw new RuntimeException("Failed to instantiate IgniteConfigStore", e);
+                ExtensionConfig config = extensionConfig != null ? extensionConfig : 
+                    new ExtensionConfig(configStoreType, configStoreType, "{}");
+                return factory.buildExtension(config);
+            } catch (IOException e) {
+                throw new TikaConfigException("Failed to create ConfigStore: " + configStoreType, e);
             }
         }
 
         // Try to load as a fully qualified class name
         try {
-            LOG.info("Creating ConfigStore from class: {}", type);
-            Class<?> storeClass = Class.forName(type);
+            LOG.info("Creating ConfigStore from class: {}", configStoreType);
+            Class<?> storeClass = Class.forName(configStoreType);
             if (!ConfigStore.class.isAssignableFrom(storeClass)) {
-                throw new RuntimeException(
-                    "Class " + type + " does not implement ConfigStore interface");
+                throw new TikaConfigException(
+                    "Class " + configStoreType + " does not implement ConfigStore interface");
+            }
+            ConfigStore store = (ConfigStore) storeClass.getDeclaredConstructor().newInstance();
+            if (extensionConfig != null) {
+                ((InMemoryConfigStore) store).setExtensionConfig(extensionConfig);
             }
-            return (ConfigStore) storeClass.getDeclaredConstructor().newInstance();
+            return store;
         } catch (ClassNotFoundException e) {
-            throw new RuntimeException(
-                "Unknown ConfigStore type: " + type + ". Use 'memory', 'ignite', or a fully qualified class name.", e);
+            throw new TikaConfigException(
+                "Unknown ConfigStore type: " + configStoreType + 
+                ". Available types: memory, " + String.join(", ", factoryMap.keySet()), e);
         } catch (Exception e) {
-            throw new RuntimeException("Failed to instantiate ConfigStore: " + type, e);
+            throw new TikaConfigException("Failed to instantiate ConfigStore: " + configStoreType, e);
         }
     }
 }

tika-pipes/tika-pipes-core/src/main/java/org/apache/tika/pipes/core/config/InMemoryConfigStore.java

@@ -28,6 +28,16 @@
 public class InMemoryConfigStore implements ConfigStore {
 
     private final ConcurrentHashMap<String, ExtensionConfig> store = new ConcurrentHashMap<>();
+    private ExtensionConfig extensionConfig;
+
+    @Override
+    public ExtensionConfig getExtensionConfig() {
+        return extensionConfig;
+    }
+
+    public void setExtensionConfig(ExtensionConfig extensionConfig) {
+        this.extensionConfig = extensionConfig;
+    }
 
     @Override
     public void put(String id, ExtensionConfig config) {

tika-pipes/tika-pipes-core/src/test/java/org/apache/tika/pipes/core/config/LoggingConfigStore.java

@@ -35,6 +35,12 @@ public class LoggingConfigStore implements ConfigStore {
 
     private static final Logger LOG = LoggerFactory.getLogger(LoggingConfigStore.class);
     private final Map<String, ExtensionConfig> store = new HashMap<>();
+    private ExtensionConfig extensionConfig;
+    
+    @Override
+    public ExtensionConfig getExtensionConfig() {
+        return extensionConfig;
+    }
 
     @Override
     public void put(String id, ExtensionConfig config) {