enforce timeout for file processing in ctags

fixes #2812

Author: Vladimir Kotal

opengrok-indexer/src/main/java/org/opengrok/indexer/analysis/Ctags.java

@@ -34,9 +34,10 @@
 import java.nio.charset.StandardCharsets;
 import java.util.ArrayList;
 import java.util.List;
+import java.util.Timer;
+import java.util.TimerTask;
 import java.util.logging.Level;
 import java.util.logging.Logger;
-import org.opengrok.indexer.configuration.RuntimeEnvironment;
 import org.opengrok.indexer.logger.LoggerFactory;
 import org.opengrok.indexer.util.IOUtils;
 import org.opengrok.indexer.util.SourceSplitter;
@@ -52,13 +53,13 @@ public class Ctags implements Resettable {
 
     private volatile boolean closing;
     private Process ctags;
-    private Thread errThread;
     private OutputStreamWriter ctagsIn;
     private BufferedReader ctagsOut;
     private static final String CTAGS_FILTER_TERMINATOR = "__ctags_done_with_file__";
     private String binary;
     private String CTagsExtraOptionsFile = null;
     private int tabSize;
+    private int timeout = 0; // in seconds
 
     private boolean junit_testing = false;
 
@@ -92,6 +93,14 @@ public void setCTagsExtraOptionsFile(String CTagsExtraOptionsFile) {
         this.CTagsExtraOptionsFile = CTagsExtraOptionsFile;
     }
 
+    public void setTimeout(int timeout) {
+        this.timeout = timeout;
+    }
+
+    public int getTimeout() {
+        return this.timeout;
+    }
+
     /**
      * Resets the instance for use for another file but without closing any
      * running ctags instance.
@@ -116,7 +125,6 @@ public void close() throws IOException {
     }
 
     private void initialize() throws IOException {
-        RuntimeEnvironment env = RuntimeEnvironment.getInstance();
         ProcessBuilder processBuilder;
         List<String> command = new ArrayList<>();
 
@@ -197,14 +205,14 @@ private void initialize() throws IOException {
         ctagsOut = new BufferedReader(new InputStreamReader(ctags.getInputStream(),
             StandardCharsets.UTF_8));
 
-        errThread = new Thread(() -> {
+        Thread errThread = new Thread(() -> {
             try (BufferedReader error = new BufferedReader(new InputStreamReader(ctags.getErrorStream(),
                     StandardCharsets.UTF_8))) {
                 String s;
                 while ((s = error.readLine()) != null) {
                     if (s.length() > 0) {
                         LOGGER.log(Level.WARNING, "Error from ctags: {0}",
-                            s);
+                                s);
                     }
                     if (closing) {
                         break;
@@ -369,7 +377,7 @@ public Definitions doCtags(String file) throws IOException,
                 LOGGER.log(Level.WARNING, "Ctags process exited with exit value {0}",
                         exitValue);
                 // Throw the following to indicate non-I/O error for retry.
-                throw new InterruptedException("ctags died");
+                throw new InterruptedException("ctags process died");
             } catch (IllegalThreadStateException exp) {
                 // The ctags process is still running.
             }
@@ -390,7 +398,35 @@ public Definitions doCtags(String file) throws IOException,
             if (Thread.interrupted()) {
                 throw new InterruptedException("flush()");
             }
+
+            int timeout = this.timeout * 1000;
+            Timer timer = null;
+            /*
+             * Setup timer thread to make sure the ctags process completes and the indexer can
+             * make progress instead of hanging the whole operation.
+             */
+            if (timeout != 0) {
+                timer = new Timer();
+                timer.schedule(new TimerTask() {
+                    @Override public void run() {
+                    LOGGER.log(Level.WARNING,
+                            String.format("Terminating ctags process for file '%s' " +
+                                    "due to timeout %d seconds", file, timeout / 1000));
+                    try {
+                        close();
+                    } catch (IOException e) {
+                        LOGGER.log(Level.WARNING, "Failed to terminate overly long ctags command");
+                    }
+                    }
+                }, timeout);
+            }
+
             readTags(rdr);
+
+            if (timer != null) {
+                timer.cancel();
+            }
+
             ret = rdr.getDefinitions();
         } catch (IOException ex) {
             /*

opengrok-indexer/src/main/java/org/opengrok/indexer/configuration/Configuration.java

@@ -207,6 +207,7 @@ public final class Configuration {
     private int tabSize;
     private int commandTimeout; // in seconds
     private int interactiveCommandTimeout; // in seconds
+    private int ctagsTimeout; // in seconds
     private boolean scopesEnabled;
     private boolean projectsEnabled;
     private boolean foldingEnabled;
@@ -376,6 +377,24 @@ public void setInteractiveCommandTimeout(int commandTimeout) throws IllegalArgum
         this.interactiveCommandTimeout = commandTimeout;
     }
 
+    public int getCtagsTimeout() {
+        return ctagsTimeout;
+    }
+
+    /**
+     * Set the ctags timeout to a new value.
+     *
+     * @param timeout the new value
+     * @throws IllegalArgumentException when the timeout is negative
+     */
+    public void setCtagsTimeout(int timeout) throws IllegalArgumentException {
+        if (commandTimeout < 0) {
+            throw new IllegalArgumentException(
+                    String.format(NEGATIVE_NUMBER_ERROR, "ctagsTimeout", timeout));
+        }
+        this.ctagsTimeout = timeout;
+    }
+
     public String getStatisticsFilePath() {
         return statisticsFilePath;
     }
@@ -411,13 +430,10 @@ public void setGroupsCollapseThreshold(int groupsCollapseThreshold) throws Illeg
     }
 
     /**
-     * Creates a new instance of Configuration.
+     * Creates a new instance of Configuration with default values.
      */
     public Configuration() {
-        /**
-         * This list of calls is sorted alphabetically so please keep it.
-         */
-        // defaults for an opengrok instance configuration
+        // This list of calls is sorted alphabetically so please keep it.
         cmds = new HashMap<>();
         setAllowedSymlinks(new HashSet<>());
         setAuthorizationWatchdogEnabled(false);
@@ -430,6 +446,7 @@ public Configuration() {
         setContextLimit((short) 10);
         //contextSurround is default(short)
         //ctags is default(String)
+        setCtagsTimeout(30);
         setCurrentIndexedCollapseThreshold(27);
         setDataRoot(null);
         setDisplayRepositories(true);

opengrok-indexer/src/main/java/org/opengrok/indexer/configuration/RuntimeEnvironment.java

@@ -301,6 +301,14 @@ public int getInteractiveCommandTimeout() {
     public void setInteractiveCommandTimeout(int timeout) {
         setConfigurationValue("interactiveCommandTimeout", timeout);
     }
+
+    public int getCtagsTimeout() {
+        return (int) getConfigurationValue("ctagsTimeout");
+    }
+
+    public void setCtagsTimeout(int timeout) {
+        setConfigurationValue("ctagsTimeout", timeout);
+    }
 
     public Statistics getStatistics() {
         return statistics;

opengrok-indexer/src/main/java/org/opengrok/indexer/index/IndexDatabase.java

@@ -733,19 +733,24 @@ private void removeFile(boolean removeHistory) throws IOException {
      */
     private void addFile(File file, String path, Ctags ctags)
             throws IOException, InterruptedException {
+
+        RuntimeEnvironment env = RuntimeEnvironment.getInstance();
         AbstractAnalyzer fa = getAnalyzerFor(file, path);
 
         for (IndexChangedListener listener : listeners) {
             listener.fileAdd(path, fa.getClass().getSimpleName());
         }
 
         ctags.setTabSize(project != null ? project.getTabSize() : 0);
+        if (env.getCtagsTimeout() != 0) {
+            ctags.setTimeout(env.getCtagsTimeout());
+        }
         if (ctags.getBinary() != null) {
             fa.setCtags(ctags);
         }
         fa.setProject(Project.getProject(path));
-        fa.setScopesEnabled(RuntimeEnvironment.getInstance().isScopesEnabled());
-        fa.setFoldingEnabled(RuntimeEnvironment.getInstance().isFoldingEnabled());
+        fa.setScopesEnabled(env.isScopesEnabled());
+        fa.setFoldingEnabled(env.isFoldingEnabled());
 
         Document doc = new Document();
         try (Writer xrefOut = newXrefWriter(fa, path)) {