Merge pull request #55 from wangguanquan/fix#54

Fix#54

Author: bells

pom.xml

@@ -59,12 +59,24 @@
             <artifactId>httpclient</artifactId>
             <version>4.4.1</version>
         </dependency>
+        <dependency>
+            <groupId>org.apache.logging.log4j</groupId>
+            <artifactId>log4j-core</artifactId>
+            <version>2.7</version>
+            <scope>provided</scope>
+        </dependency>
         <dependency>
             <groupId>org.apache.logging.log4j</groupId>
             <artifactId>log4j-api</artifactId>
             <version>2.7</version>
             <scope>provided</scope>
         </dependency>
+        <dependency>
+            <groupId>org.codelibs</groupId>
+            <artifactId>elasticsearch-cluster-runner</artifactId>
+            <version>${project.version}.0</version>
+            <scope>test</scope>
+        </dependency>
     </dependencies>
 
 

src/main/java/com/bellszhu/elasticsearch/plugin/synonym/analysis/LocalSynonymFile.java

@@ -16,7 +16,10 @@
 import java.io.InputStreamReader;
 import java.io.Reader;
 import java.io.StringReader;
+import java.net.URL;
+import java.nio.file.Files;
 import java.nio.file.Path;
+import java.nio.file.Paths;
 
 
 /**
@@ -51,57 +54,102 @@ public class LocalSynonymFile implements SynonymFile {
         this.env = env;
         this.location = location;
 
-        this.synonymFilePath = env.configFile().resolve(location);
+        this.synonymFilePath = deepSearch();
         isNeedReloadSynonymMap();
     }
 
     @Override
     public SynonymMap reloadSynonymMap() {
         try {
-            logger.info("start reload local synonym from {}.", location);
+            logger.info("start reload local synonym from {}.", synonymFilePath);
             Reader rulesReader = getReader();
             SynonymMap.Builder parser = RemoteSynonymFile.getSynonymParser(rulesReader, format, expand, analyzer);
             return parser.build();
         } catch (Exception e) {
-            logger.error("reload local synonym {} error!", e, location);
+            logger.error("reload local synonym {} error!", synonymFilePath, e);
             throw new IllegalArgumentException(
                     "could not reload local synonyms file to build synonyms", e);
         }
 
     }
 
     public Reader getReader() {
+        /*
+        Just deleted when reading the file, Returns empty synonym
+          keyword if file not exists.
+        A small probability event.
+         */
+        if (!Files.exists(synonymFilePath)) {
+            return new StringReader("");
+        }
         try (BufferedReader br = new BufferedReader(new InputStreamReader(
                 synonymFilePath.toUri().toURL().openStream(), Charsets.UTF_8))) {
-            StringBuffer sb = new StringBuffer();
+            StringBuilder sb = new StringBuilder();
             String line;
             while ((line = br.readLine()) != null) {
                 logger.info("reload local synonym: {}", line);
                 sb.append(line).append(System.getProperty("line.separator"));
             }
             return new StringReader(sb.toString());
         } catch (IOException e) {
-            logger.error("get local synonym reader {} error!", e, location);
-            throw new IllegalArgumentException(
-                    "IOException while reading local synonyms file", e);
+            logger.error("get local synonym reader {} error!", location, e);
+//            throw new IllegalArgumentException(
+//                    "IOException while reading local synonyms file", e);
+            // Fix #54 Returns blank if synonym file has be deleted.
+            return new StringReader("");
         }
     }
 
     @Override
     public boolean isNeedReloadSynonymMap() {
         try {
+            /*
+            If the file does not exist, it will be scanned every time
+              until the file is restored.
+             */
+            if (!Files.exists(synonymFilePath) && !Files.exists(synonymFilePath = deepSearch())) {
+                return false;
+            }
             File synonymFile = synonymFilePath.toFile();
             if (synonymFile.exists()
                     && lastModified < synonymFile.lastModified()) {
                 lastModified = synonymFile.lastModified();
                 return true;
             }
         } catch (Exception e) {
-            logger.error("check need reload local synonym {} error!", e,
-                    location);
+            logger.error("check need reload local synonym {} error!", location, e);
         }
 
         return false;
     }
 
+    /**
+     * Deep search synonym file.
+     * Step 1. Query the 'sysnonym_path' parameter as an absolute path
+     * Step 2. Query the es config path
+     * Step 3. Query in current relative path
+     * <p>
+     * Override this method to expend search path
+     *
+     * @return the synonym path.
+     */
+    protected Path deepSearch() {
+        Path path;
+        // Load setting config as absolute path
+        if (Files.exists(Paths.get(location))) {
+            path = Paths.get(location);
+            // Load from setting config path
+        } else if (Files.exists(env.configFile().resolve(location))) {
+            path = env.configFile().resolve(location);
+            // Load from current relative path
+        } else {
+            URL url = getClass().getClassLoader().getResource(location);
+            if (url != null) {
+                path = Paths.get(url.getFile());
+            } else {
+                path = env.configFile().resolve(location);
+            }
+        }
+        return path;
+    }
 }

src/main/java/com/bellszhu/elasticsearch/plugin/synonym/analysis/RemoteSynonymFile.java

@@ -92,7 +92,7 @@ public SynonymMap reloadSynonymMap() {
             parser = getSynonymParser(rulesReader, format, expand, analyzer);
             return parser.build();
         } catch (Exception e) {
-            logger.error("reload remote synonym {} error!", e, location);
+            logger.error("reload remote synonym {} error!", location, e);
             throw new IllegalArgumentException(
                     "could not reload remote synonyms file to build synonyms",
                     e);
@@ -112,7 +112,7 @@ private CloseableHttpResponse executeHttpRequest(HttpUriRequest httpUriRequest)
             try {
                 return httpclient.execute(httpUriRequest);
             } catch (IOException e) {
-                logger.error("Unable to execute HTTP request: {}", e);
+                logger.error("Unable to execute HTTP request.", e);
             }
             return null;
         });
@@ -122,7 +122,7 @@ private CloseableHttpResponse executeHttpRequest(HttpUriRequest httpUriRequest)
      * Download custom terms from a remote server
      */
     public Reader getReader() {
-        Reader reader = null;
+        Reader reader;
         RequestConfig rc = RequestConfig.custom()
                 .setConnectionRequestTimeout(10 * 1000)
                 .setConnectTimeout(10 * 1000).setSocketTimeout(60 * 1000)
@@ -145,19 +145,21 @@ public Reader getReader() {
 
                 br = new BufferedReader(new InputStreamReader(response
                         .getEntity().getContent(), charset));
-                StringBuffer sb = new StringBuffer();
+                StringBuilder sb = new StringBuilder();
                 String line;
                 while ((line = br.readLine()) != null) {
                     logger.info("reload remote synonym: {}", line);
                     sb.append(line)
                             .append(System.getProperty("line.separator"));
                 }
                 reader = new StringReader(sb.toString());
-            }
+            } else reader = new StringReader("");
         } catch (Exception e) {
-            logger.error("get remote synonym reader {} error!", e, location);
-            throw new IllegalArgumentException(
-                    "Exception while reading remote synonyms file", e);
+            logger.error("get remote synonym reader {} error!", location, e);
+//            throw new IllegalArgumentException(
+//                    "Exception while reading remote synonyms file", e);
+            // Fix #54 Returns blank if synonym file has be deleted.
+            reader = new StringReader("");
         } finally {
             try {
                 if (br != null) {