Merged branch 'jetty-9.4.x' into 'jetty-10.0.x'.

sbordet · sbordet · commit fd792bc637a7 · 2019-10-20T17:03:21.000+02:00
diff --git a/jetty-servlets/src/main/java/org/eclipse/jetty/servlets/DoSFilter.java b/jetty-servlets/src/main/java/org/eclipse/jetty/servlets/DoSFilter.java
@@ -121,7 +121,7 @@
  * </dl>
  * <p>
  * This filter should be configured for {@link DispatcherType#REQUEST} and {@link DispatcherType#ASYNC} and with
- * <code>&lt;async-supported&gt;true&lt;/async-supported&gt;</code>.
+ * {@code <async-supported>true</async-supported>}.
  * </p>
  */
 @ManagedObject("limits exposure to abuse from request flooding, whether malicious, or as a result of a misconfigured client")
@@ -146,7 +146,6 @@ public class DoSFilter implements Filter
     private static final long __DEFAULT_MAX_REQUEST_MS_INIT_PARAM = 30000L;
     private static final long __DEFAULT_MAX_IDLE_TRACKER_MS_INIT_PARAM = 30000L;
 
-    static final String NAME = "name";
     static final String MANAGED_ATTR_INIT_PARAM = "managedAttr";
     static final String MAX_REQUESTS_PER_S_INIT_PARAM = "maxRequestsPerSec";
     static final String DELAY_MS_INIT_PARAM = "delayMs";
@@ -384,14 +383,13 @@ protected void doFilter(HttpServletRequest request, HttpServletResponse response
                 long throttleMs = getThrottleMs();
                 if (!Boolean.TRUE.equals(throttled) && throttleMs > 0)
                 {
-                    final int priority = getPriority(request, tracker);
+                    int priority = getPriority(request, tracker);
                     request.setAttribute(__THROTTLED, Boolean.TRUE);
                     if (isInsertHeaders())
                         response.addHeader("DoSFilter", "throttled");
                     AsyncContext asyncContext = request.startAsync();
                     request.setAttribute(_suspended, Boolean.TRUE);
-                    if (throttleMs > 0)
-                        asyncContext.setTimeout(throttleMs);
+                    asyncContext.setTimeout(throttleMs);
                     asyncContext.addListener(_listeners[priority]);
                     _queues[priority].add(asyncContext);
                     if (LOG.isDebugEnabled())
@@ -467,14 +465,7 @@ protected void doFilter(HttpServletRequest request, HttpServletResponse response
     protected void doFilterChain(FilterChain chain, final HttpServletRequest request, final HttpServletResponse response) throws IOException, ServletException
     {
         final Thread thread = Thread.currentThread();
-        Runnable requestTimeout = new Runnable()
-        {
-            @Override
-            public void run()
-            {
-                onRequestTimeout(request, response, thread);
-            }
-        };
+        Runnable requestTimeout = () -> onRequestTimeout(request, response, thread);
         Scheduler.Task task = _scheduler.schedule(requestTimeout, getMaxRequestMs(), TimeUnit.MILLISECONDS);
         try
         {
@@ -527,7 +518,7 @@ protected void onRequestTimeout(HttpServletRequest request, HttpServletResponse
      * @param tracker the rate tracker for this request
      * @return the priority for this request
      */
-    protected int getPriority(HttpServletRequest request, RateTracker tracker)
+    private int getPriority(HttpServletRequest request, RateTracker tracker)
     {
         if (extractUserId(request) != null)
             return USER_AUTH;
@@ -544,7 +535,7 @@ protected int getMaxPriority()
         return USER_AUTH;
     }
 
-    public void schedule(RateTracker tracker)
+    private void schedule(RateTracker tracker)
     {
         _scheduler.schedule(tracker, getMaxIdleTrackerMs(), TimeUnit.MILLISECONDS);
     }
@@ -565,7 +556,7 @@ public void schedule(RateTracker tracker)
      * @param request the current request
      * @return the request rate tracker for the current connection
      */
-    public RateTracker getRateTracker(ServletRequest request)
+    RateTracker getRateTracker(ServletRequest request)
     {
         HttpSession session = ((HttpServletRequest)request).getSession(false);
 
@@ -617,7 +608,7 @@ else if (session != null)
         return tracker;
     }
 
-    public void addToRateTracker(RateTracker tracker)
+    private void addToRateTracker(RateTracker tracker)
     {
         _rateTrackers.put(tracker.getId(), tracker);
     }
@@ -700,7 +691,7 @@ private byte[] addressToBytes(String address)
             byte[] result = new byte[4];
             for (int i = 0; i < result.length; ++i)
             {
-                result[i] = ((Integer)Integer.parseInt(ipv4Matcher.group(i + 1))).byteValue();
+                result[i] = Integer.valueOf(ipv4Matcher.group(i + 1)).byteValue();
             }
             return result;
         }
@@ -1237,7 +1228,7 @@ protected void removeFromRateTrackers(DoSFilter filter, String id)
                 LOG.debug("Tracker removed: {}", getId());
         }
 
-        protected void addToRateTrackers(DoSFilter filter, RateTracker tracker)
+        private void addToRateTrackers(DoSFilter filter, RateTracker tracker)
         {
             if (filter == null)
                 return;
@@ -1277,7 +1268,7 @@ public String toString()
         }
     }
 
-    class FixedRateTracker extends RateTracker
+    private static class FixedRateTracker extends RateTracker
     {
         public FixedRateTracker(ServletContext context, String filterName, String id, int type, int numRecentRequestsTracked)
         {
@@ -1306,15 +1297,15 @@ public String toString()
         }
     }
 
-    private class DoSTimeoutAsyncListener implements AsyncListener
+    private static class DoSTimeoutAsyncListener implements AsyncListener
     {
         @Override
-        public void onStartAsync(AsyncEvent event) throws IOException
+        public void onStartAsync(AsyncEvent event)
         {
         }
 
         @Override
-        public void onComplete(AsyncEvent event) throws IOException
+        public void onComplete(AsyncEvent event)
         {
         }
 
@@ -1325,7 +1316,7 @@ public void onTimeout(AsyncEvent event) throws IOException
         }
 
         @Override
-        public void onError(AsyncEvent event) throws IOException
+        public void onError(AsyncEvent event)
         {
         }
     }
diff --git a/jetty-util/src/main/java/org/eclipse/jetty/util/Scanner.java b/jetty-util/src/main/java/org/eclipse/jetty/util/Scanner.java
@@ -49,11 +49,11 @@ public class Scanner extends AbstractLifeCycle
     private static int __scannerId = 0;
     private int _scanInterval;
     private int _scanCount = 0;
-    private final List<Listener> _listeners = new ArrayList<Listener>();
-    private final Map<String, TimeNSize> _prevScan = new HashMap<String, TimeNSize>();
-    private final Map<String, TimeNSize> _currentScan = new HashMap<String, TimeNSize>();
+    private final List<Listener> _listeners = new ArrayList<>();
+    private final Map<String, TimeNSize> _prevScan = new HashMap<>();
+    private final Map<String, TimeNSize> _currentScan = new HashMap<>();
     private FilenameFilter _filter;
-    private final List<File> _scanDirs = new ArrayList<File>();
+    private final List<File> _scanDirs = new ArrayList<>();
     private volatile boolean _running = false;
     private boolean _reportExisting = true;
     private boolean _reportDirs = true;
@@ -66,8 +66,7 @@ public enum Notification
         ADDED, CHANGED, REMOVED
     }
 
-    ;
-    private final Map<String, Notification> _notifications = new HashMap<String, Notification>();
+    private final Map<String, Notification> _notifications = new HashMap<>();
 
     static class TimeNSize
     {
@@ -412,11 +411,7 @@ public synchronized void scan()
                 if (l instanceof ScanListener)
                     ((ScanListener)l).scan();
             }
-            catch (Exception e)
-            {
-                LOG.warn(e);
-            }
-            catch (Error e)
+            catch (Throwable e)
             {
                 LOG.warn(e);
             }
@@ -428,16 +423,11 @@ public synchronized void scan()
      */
     public synchronized void scanFiles()
     {
-        if (_scanDirs == null)
-            return;
-
         _currentScan.clear();
-        Iterator<File> itor = _scanDirs.iterator();
-        while (itor.hasNext())
+        for (File dir : _scanDirs)
         {
-            File dir = itor.next();
-
             if ((dir != null) && (dir.exists()))
+            {
                 try
                 {
                     scanFile(dir.getCanonicalFile(), _currentScan, 0);
@@ -446,6 +436,7 @@ public synchronized void scanFiles()
                 {
                     LOG.warn("Error scanning files.", e);
                 }
+            }
         }
     }
 
@@ -455,11 +446,11 @@ public synchronized void scanFiles()
      * @param currentScan the info from the most recent pass
      * @param oldScan info from the previous pass
      */
-    public synchronized void reportDifferences(Map<String, TimeNSize> currentScan, Map<String, TimeNSize> oldScan)
+    private synchronized void reportDifferences(Map<String, TimeNSize> currentScan, Map<String, TimeNSize> oldScan)
     {
         // scan the differences and add what was found to the map of notifications:
 
-        Set<String> oldScanKeys = new HashSet<String>(oldScan.keySet());
+        Set<String> oldScanKeys = new HashSet<>(oldScan.keySet());
 
         // Look for new and changed files
         for (Map.Entry<String, TimeNSize> entry : currentScan.entrySet())
@@ -484,17 +475,8 @@ public synchronized void reportDifferences(Map<String, TimeNSize> currentScan, M
             else if (!oldScan.get(file).equals(currentScan.get(file)))
             {
                 Notification old = _notifications.put(file, Notification.CHANGED);
-                if (old != null)
-                {
-                    switch (old)
-                    {
-                        case ADDED:
-                            _notifications.put(file, Notification.ADDED);
-                            break;
-                        default:
-                            break;
-                    }
-                }
+                if (old == Notification.ADDED)
+                    _notifications.put(file, Notification.ADDED);
             }
         }
 
@@ -504,17 +486,8 @@ else if (!oldScan.get(file).equals(currentScan.get(file)))
             if (!currentScan.containsKey(file))
             {
                 Notification old = _notifications.put(file, Notification.REMOVED);
-                if (old != null)
-                {
-                    switch (old)
-                    {
-                        case ADDED:
-                            _notifications.remove(file);
-                            break;
-                        default:
-                            break;
-                    }
-                }
+                if (old == Notification.ADDED)
+                    _notifications.remove(file);
             }
         }
 
@@ -523,7 +496,7 @@ else if (!oldScan.get(file).equals(currentScan.get(file)))
 
         // Process notifications
         // Only process notifications that are for stable files (ie same in old and current scan).
-        List<String> bulkChanges = new ArrayList<String>();
+        List<String> bulkChanges = new ArrayList<>();
         for (Iterator<Entry<String, Notification>> iter = _notifications.entrySet().iterator(); iter.hasNext(); )
         {
             Entry<String, Notification> entry = iter.next();
@@ -577,7 +550,7 @@ private void scanFile(File f, Map<String, TimeNSize> scanInfoMap, int depth)
 
             if (f.isFile() || depth > 0 && _reportDirs && f.isDirectory())
             {
-                if ((_filter == null) || ((_filter != null) && _filter.accept(f.getParentFile(), f.getName())))
+                if (_filter == null || _filter.accept(f.getParentFile(), f.getName()))
                 {
                     if (LOG.isDebugEnabled())
                         LOG.debug("scan accepted {}", f);
@@ -597,9 +570,9 @@ private void scanFile(File f, Map<String, TimeNSize> scanInfoMap, int depth)
                 File[] files = f.listFiles();
                 if (files != null)
                 {
-                    for (int i = 0; i < files.length; i++)
+                    for (File file : files)
                     {
-                        scanFile(files[i], scanInfoMap, depth + 1);
+                        scanFile(file, scanInfoMap, depth + 1);
                     }
                 }
                 else
@@ -624,20 +597,14 @@ private void warn(Object listener, String filename, Throwable th)
      */
     private void reportAddition(String filename)
     {
-        Iterator<Listener> itor = _listeners.iterator();
-        while (itor.hasNext())
+        for (Listener l : _listeners)
         {
-            Listener l = itor.next();
             try
             {
                 if (l instanceof DiscreteListener)
                     ((DiscreteListener)l).fileAdded(filename);
             }
-            catch (Exception e)
-            {
-                warn(l, filename, e);
-            }
-            catch (Error e)
+            catch (Throwable e)
             {
                 warn(l, filename, e);
             }
@@ -651,20 +618,14 @@ private void reportAddition(String filename)
      */
     private void reportRemoval(String filename)
     {
-        Iterator<Listener> itor = _listeners.iterator();
-        while (itor.hasNext())
+        for (Object l : _listeners)
         {
-            Object l = itor.next();
             try
             {
                 if (l instanceof DiscreteListener)
                     ((DiscreteListener)l).fileRemoved(filename);
             }
-            catch (Exception e)
-            {
-                warn(l, filename, e);
-            }
-            catch (Error e)
+            catch (Throwable e)
             {
                 warn(l, filename, e);
             }
@@ -678,20 +639,14 @@ private void reportRemoval(String filename)
      */
     private void reportChange(String filename)
     {
-        Iterator<Listener> itor = _listeners.iterator();
-        while (itor.hasNext())
+        for (Listener l : _listeners)
         {
-            Listener l = itor.next();
             try
             {
                 if (l instanceof DiscreteListener)
                     ((DiscreteListener)l).fileChanged(filename);
             }
-            catch (Exception e)
-            {
-                warn(l, filename, e);
-            }
-            catch (Error e)
+            catch (Throwable e)
             {
                 warn(l, filename, e);
             }
@@ -700,20 +655,14 @@ private void reportChange(String filename)
 
     private void reportBulkChanges(List<String> filenames)
     {
-        Iterator<Listener> itor = _listeners.iterator();
-        while (itor.hasNext())
+        for (Listener l : _listeners)
         {
-            Listener l = itor.next();
             try
             {
                 if (l instanceof BulkListener)
                     ((BulkListener)l).filesChanged(filenames);
             }
-            catch (Exception e)
-            {
-                warn(l, filenames.toString(), e);
-            }
-            catch (Error e)
+            catch (Throwable e)
             {
                 warn(l, filenames.toString(), e);
             }

Original file line number	Diff line number	Diff line change
`@@ -121,7 +121,7 @@`
`121`	`121`	`* </dl>`
`122`	`122`	`* <p>`
`123`	`123`	`* This filter should be configured for {@link DispatcherType#REQUEST} and {@link DispatcherType#ASYNC} and with`
`124`		`- * <code><async-supported>true</async-supported></code>.`
	`124`	`+ * {@code <async-supported>true</async-supported>}.`
`125`	`125`	`* </p>`
`126`	`126`	`*/`
`127`	`127`	`@ManagedObject("limits exposure to abuse from request flooding, whether malicious, or as a result of a misconfigured client")`
`@@ -146,7 +146,6 @@ public class DoSFilter implements Filter`
`146`	`146`	`private static final long __DEFAULT_MAX_REQUEST_MS_INIT_PARAM = 30000L;`
`147`	`147`	`private static final long __DEFAULT_MAX_IDLE_TRACKER_MS_INIT_PARAM = 30000L;`
`148`	`148`
`149`		`- static final String NAME = "name";`
`150`	`149`	`static final String MANAGED_ATTR_INIT_PARAM = "managedAttr";`
`151`	`150`	`static final String MAX_REQUESTS_PER_S_INIT_PARAM = "maxRequestsPerSec";`
`152`	`151`	`static final String DELAY_MS_INIT_PARAM = "delayMs";`
`@@ -384,14 +383,13 @@ protected void doFilter(HttpServletRequest request, HttpServletResponse response`
`384`	`383`	`long throttleMs = getThrottleMs();`
`385`	`384`	`if (!Boolean.TRUE.equals(throttled) && throttleMs > 0)`
`386`	`385`	`{`
`387`		`- final int priority = getPriority(request, tracker);`
	`386`	`+ int priority = getPriority(request, tracker);`
`388`	`387`	`request.setAttribute(__THROTTLED, Boolean.TRUE);`
`389`	`388`	`if (isInsertHeaders())`
`390`	`389`	`response.addHeader("DoSFilter", "throttled");`
`391`	`390`	`AsyncContext asyncContext = request.startAsync();`
`392`	`391`	`request.setAttribute(_suspended, Boolean.TRUE);`
`393`		`- if (throttleMs > 0)`
`394`		`- asyncContext.setTimeout(throttleMs);`
	`392`	`+ asyncContext.setTimeout(throttleMs);`
`395`	`393`	`asyncContext.addListener(_listeners[priority]);`
`396`	`394`	`_queues[priority].add(asyncContext);`
`397`	`395`	`if (LOG.isDebugEnabled())`
`@@ -467,14 +465,7 @@ protected void doFilter(HttpServletRequest request, HttpServletResponse response`
`467`	`465`	`protected void doFilterChain(FilterChain chain, final HttpServletRequest request, final HttpServletResponse response) throws IOException, ServletException`
`468`	`466`	`{`
`469`	`467`	`final Thread thread = Thread.currentThread();`
`470`		`- Runnable requestTimeout = new Runnable()`
`471`		`- {`
`472`		`- @Override`
`473`		`- public void run()`
`474`		`- {`
`475`		`- onRequestTimeout(request, response, thread);`
`476`		`- }`
`477`		`- };`
	`468`	`+ Runnable requestTimeout = () -> onRequestTimeout(request, response, thread);`
`478`	`469`	`Scheduler.Task task = _scheduler.schedule(requestTimeout, getMaxRequestMs(), TimeUnit.MILLISECONDS);`
`479`	`470`	`try`
`480`	`471`	`{`
`@@ -527,7 +518,7 @@ protected void onRequestTimeout(HttpServletRequest request, HttpServletResponse`
`527`	`518`	`* @param tracker the rate tracker for this request`
`528`	`519`	`* @return the priority for this request`
`529`	`520`	`*/`
`530`		`- protected int getPriority(HttpServletRequest request, RateTracker tracker)`
	`521`	`+ private int getPriority(HttpServletRequest request, RateTracker tracker)`
`531`	`522`	`{`
`532`	`523`	`if (extractUserId(request) != null)`
`533`	`524`	`return USER_AUTH;`
`@@ -544,7 +535,7 @@ protected int getMaxPriority()`
`544`	`535`	`return USER_AUTH;`
`545`	`536`	`}`
`546`	`537`
`547`		`- public void schedule(RateTracker tracker)`
	`538`	`+ private void schedule(RateTracker tracker)`
`548`	`539`	`{`
`549`	`540`	`_scheduler.schedule(tracker, getMaxIdleTrackerMs(), TimeUnit.MILLISECONDS);`
`550`	`541`	`}`
`@@ -565,7 +556,7 @@ public void schedule(RateTracker tracker)`
`565`	`556`	`* @param request the current request`
`566`	`557`	`* @return the request rate tracker for the current connection`
`567`	`558`	`*/`
`568`		`- public RateTracker getRateTracker(ServletRequest request)`
	`559`	`+ RateTracker getRateTracker(ServletRequest request)`
`569`	`560`	`{`
`570`	`561`	`HttpSession session = ((HttpServletRequest)request).getSession(false);`
`571`	`562`
`@@ -617,7 +608,7 @@ else if (session != null)`
`617`	`608`	`return tracker;`
`618`	`609`	`}`
`619`	`610`
`620`		`- public void addToRateTracker(RateTracker tracker)`
	`611`	`+ private void addToRateTracker(RateTracker tracker)`
`621`	`612`	`{`
`622`	`613`	`_rateTrackers.put(tracker.getId(), tracker);`
`623`	`614`	`}`
`@@ -700,7 +691,7 @@ private byte[] addressToBytes(String address)`
`700`	`691`	`byte[] result = new byte[4];`
`701`	`692`	`for (int i = 0; i < result.length; ++i)`
`702`	`693`	`{`
`703`		`- result[i] = ((Integer)Integer.parseInt(ipv4Matcher.group(i + 1))).byteValue();`
	`694`	`+ result[i] = Integer.valueOf(ipv4Matcher.group(i + 1)).byteValue();`
`704`	`695`	`}`
`705`	`696`	`return result;`
`706`	`697`	`}`
`@@ -1237,7 +1228,7 @@ protected void removeFromRateTrackers(DoSFilter filter, String id)`
`1237`	`1228`	`LOG.debug("Tracker removed: {}", getId());`
`1238`	`1229`	`}`
`1239`	`1230`
`1240`		`- protected void addToRateTrackers(DoSFilter filter, RateTracker tracker)`
	`1231`	`+ private void addToRateTrackers(DoSFilter filter, RateTracker tracker)`
`1241`	`1232`	`{`
`1242`	`1233`	`if (filter == null)`
`1243`	`1234`	`return;`
`@@ -1277,7 +1268,7 @@ public String toString()`
`1277`	`1268`	`}`
`1278`	`1269`	`}`
`1279`	`1270`
`1280`		`- class FixedRateTracker extends RateTracker`
	`1271`	`+ private static class FixedRateTracker extends RateTracker`
`1281`	`1272`	`{`
`1282`	`1273`	`public FixedRateTracker(ServletContext context, String filterName, String id, int type, int numRecentRequestsTracked)`
`1283`	`1274`	`{`
`@@ -1306,15 +1297,15 @@ public String toString()`
`1306`	`1297`	`}`
`1307`	`1298`	`}`
`1308`	`1299`
`1309`		`- private class DoSTimeoutAsyncListener implements AsyncListener`
	`1300`	`+ private static class DoSTimeoutAsyncListener implements AsyncListener`
`1310`	`1301`	`{`
`1311`	`1302`	`@Override`
`1312`		`- public void onStartAsync(AsyncEvent event) throws IOException`
	`1303`	`+ public void onStartAsync(AsyncEvent event)`
`1313`	`1304`	`{`
`1314`	`1305`	`}`
`1315`	`1306`
`1316`	`1307`	`@Override`
`1317`		`- public void onComplete(AsyncEvent event) throws IOException`
	`1308`	`+ public void onComplete(AsyncEvent event)`
`1318`	`1309`	`{`
`1319`	`1310`	`}`
`1320`	`1311`
`@@ -1325,7 +1316,7 @@ public void onTimeout(AsyncEvent event) throws IOException`
`1325`	`1316`	`}`
`1326`	`1317`
`1327`	`1318`	`@Override`
`1328`		`- public void onError(AsyncEvent event) throws IOException`
	`1319`	`+ public void onError(AsyncEvent event)`
`1329`	`1320`	`{`
`1330`	`1321`	`}`
`1331`	`1322`	`}`
Original file line number	Diff line number	Diff line change
`@@ -49,11 +49,11 @@ public class Scanner extends AbstractLifeCycle`
`49`	`49`	`private static int __scannerId = 0;`
`50`	`50`	`private int _scanInterval;`
`51`	`51`	`private int _scanCount = 0;`
`52`		`- private final List<Listener> _listeners = new ArrayList<Listener>();`
`53`		`- private final Map<String, TimeNSize> _prevScan = new HashMap<String, TimeNSize>();`
`54`		`- private final Map<String, TimeNSize> _currentScan = new HashMap<String, TimeNSize>();`
	`52`	`+ private final List<Listener> _listeners = new ArrayList<>();`
	`53`	`+ private final Map<String, TimeNSize> _prevScan = new HashMap<>();`
	`54`	`+ private final Map<String, TimeNSize> _currentScan = new HashMap<>();`
`55`	`55`	`private FilenameFilter _filter;`
`56`		`- private final List<File> _scanDirs = new ArrayList<File>();`
	`56`	`+ private final List<File> _scanDirs = new ArrayList<>();`
`57`	`57`	`private volatile boolean _running = false;`
`58`	`58`	`private boolean _reportExisting = true;`
`59`	`59`	`private boolean _reportDirs = true;`
`@@ -66,8 +66,7 @@ public enum Notification`
`66`	`66`	`ADDED, CHANGED, REMOVED`
`67`	`67`	`}`
`68`	`68`
`69`		`- ;`
`70`		`- private final Map<String, Notification> _notifications = new HashMap<String, Notification>();`
	`69`	`+ private final Map<String, Notification> _notifications = new HashMap<>();`
`71`	`70`
`72`	`71`	`static class TimeNSize`
`73`	`72`	`{`
`@@ -412,11 +411,7 @@ public synchronized void scan()`
`412`	`411`	`if (l instanceof ScanListener)`
`413`	`412`	`((ScanListener)l).scan();`
`414`	`413`	`}`
`415`		`- catch (Exception e)`
`416`		`- {`
`417`		`- LOG.warn(e);`
`418`		`- }`
`419`		`- catch (Error e)`
	`414`	`+ catch (Throwable e)`
`420`	`415`	`{`
`421`	`416`	`LOG.warn(e);`
`422`	`417`	`}`
`@@ -428,16 +423,11 @@ public synchronized void scan()`
`428`	`423`	`*/`
`429`	`424`	`public synchronized void scanFiles()`
`430`	`425`	`{`
`431`		`- if (_scanDirs == null)`
`432`		`- return;`
`433`		`-`
`434`	`426`	`_currentScan.clear();`
`435`		`- Iterator<File> itor = _scanDirs.iterator();`
`436`		`- while (itor.hasNext())`
	`427`	`+ for (File dir : _scanDirs)`
`437`	`428`	`{`
`438`		`- File dir = itor.next();`
`439`		`-`
`440`	`429`	`if ((dir != null) && (dir.exists()))`
	`430`	`+ {`
`441`	`431`	`try`
`442`	`432`	`{`
`443`	`433`	`scanFile(dir.getCanonicalFile(), _currentScan, 0);`
`@@ -446,6 +436,7 @@ public synchronized void scanFiles()`
`446`	`436`	`{`
`447`	`437`	`LOG.warn("Error scanning files.", e);`
`448`	`438`	`}`
	`439`	`+ }`
`449`	`440`	`}`
`450`	`441`	`}`
`451`	`442`
`@@ -455,11 +446,11 @@ public synchronized void scanFiles()`
`455`	`446`	`* @param currentScan the info from the most recent pass`
`456`	`447`	`* @param oldScan info from the previous pass`
`457`	`448`	`*/`
`458`		`- public synchronized void reportDifferences(Map<String, TimeNSize> currentScan, Map<String, TimeNSize> oldScan)`
	`449`	`+ private synchronized void reportDifferences(Map<String, TimeNSize> currentScan, Map<String, TimeNSize> oldScan)`
`459`	`450`	`{`
`460`	`451`	`// scan the differences and add what was found to the map of notifications:`
`461`	`452`
`462`		`- Set<String> oldScanKeys = new HashSet<String>(oldScan.keySet());`
	`453`	`+ Set<String> oldScanKeys = new HashSet<>(oldScan.keySet());`
`463`	`454`
`464`	`455`	`// Look for new and changed files`
`465`	`456`	`for (Map.Entry<String, TimeNSize> entry : currentScan.entrySet())`
`@@ -484,17 +475,8 @@ public synchronized void reportDifferences(Map<String, TimeNSize> currentScan, M`
`484`	`475`	`else if (!oldScan.get(file).equals(currentScan.get(file)))`
`485`	`476`	`{`
`486`	`477`	`Notification old = _notifications.put(file, Notification.CHANGED);`
`487`		`- if (old != null)`
`488`		`- {`
`489`		`- switch (old)`
`490`		`- {`
`491`		`- case ADDED:`
`492`		`- _notifications.put(file, Notification.ADDED);`
`493`		`- break;`
`494`		`- default:`
`495`		`- break;`
`496`		`- }`
`497`		`- }`
	`478`	`+ if (old == Notification.ADDED)`
	`479`	`+ _notifications.put(file, Notification.ADDED);`
`498`	`480`	`}`
`499`	`481`	`}`
`500`	`482`
`@@ -504,17 +486,8 @@ else if (!oldScan.get(file).equals(currentScan.get(file)))`
`504`	`486`	`if (!currentScan.containsKey(file))`
`505`	`487`	`{`
`506`	`488`	`Notification old = _notifications.put(file, Notification.REMOVED);`
`507`		`- if (old != null)`
`508`		`- {`
`509`		`- switch (old)`
`510`		`- {`
`511`		`- case ADDED:`
`512`		`- _notifications.remove(file);`
`513`		`- break;`
`514`		`- default:`
`515`		`- break;`
`516`		`- }`
`517`		`- }`
	`489`	`+ if (old == Notification.ADDED)`
	`490`	`+ _notifications.remove(file);`
`518`	`491`	`}`
`519`	`492`	`}`
`520`	`493`
`@@ -523,7 +496,7 @@ else if (!oldScan.get(file).equals(currentScan.get(file)))`
`523`	`496`
`524`	`497`	`// Process notifications`
`525`	`498`	`// Only process notifications that are for stable files (ie same in old and current scan).`
`526`		`- List<String> bulkChanges = new ArrayList<String>();`
	`499`	`+ List<String> bulkChanges = new ArrayList<>();`
`527`	`500`	`for (Iterator<Entry<String, Notification>> iter = _notifications.entrySet().iterator(); iter.hasNext(); )`
`528`	`501`	`{`
`529`	`502`	`Entry<String, Notification> entry = iter.next();`
`@@ -577,7 +550,7 @@ private void scanFile(File f, Map<String, TimeNSize> scanInfoMap, int depth)`
`577`	`550`
`578`	`551`	`if (f.isFile() \|\| depth > 0 && _reportDirs && f.isDirectory())`
`579`	`552`	`{`
`580`		`- if ((_filter == null) \|\| ((_filter != null) && _filter.accept(f.getParentFile(), f.getName())))`
	`553`	`+ if (_filter == null \|\| _filter.accept(f.getParentFile(), f.getName()))`
`581`	`554`	`{`
`582`	`555`	`if (LOG.isDebugEnabled())`
`583`	`556`	`LOG.debug("scan accepted {}", f);`
`@@ -597,9 +570,9 @@ private void scanFile(File f, Map<String, TimeNSize> scanInfoMap, int depth)`
`597`	`570`	`File[] files = f.listFiles();`
`598`	`571`	`if (files != null)`
`599`	`572`	`{`
`600`		`- for (int i = 0; i < files.length; i++)`
	`573`	`+ for (File file : files)`
`601`	`574`	`{`
`602`		`- scanFile(files[i], scanInfoMap, depth + 1);`
	`575`	`+ scanFile(file, scanInfoMap, depth + 1);`
`603`	`576`	`}`
`604`	`577`	`}`
`605`	`578`	`else`
`@@ -624,20 +597,14 @@ private void warn(Object listener, String filename, Throwable th)`
`624`	`597`	`*/`
`625`	`598`	`private void reportAddition(String filename)`
`626`	`599`	`{`
`627`		`- Iterator<Listener> itor = _listeners.iterator();`
`628`		`- while (itor.hasNext())`
	`600`	`+ for (Listener l : _listeners)`
`629`	`601`	`{`
`630`		`- Listener l = itor.next();`
`631`	`602`	`try`
`632`	`603`	`{`
`633`	`604`	`if (l instanceof DiscreteListener)`
`634`	`605`	`((DiscreteListener)l).fileAdded(filename);`
`635`	`606`	`}`
`636`		`- catch (Exception e)`
`637`		`- {`
`638`		`- warn(l, filename, e);`
`639`		`- }`
`640`		`- catch (Error e)`
	`607`	`+ catch (Throwable e)`
`641`	`608`	`{`
`642`	`609`	`warn(l, filename, e);`
`643`	`610`	`}`
`@@ -651,20 +618,14 @@ private void reportAddition(String filename)`
`651`	`618`	`*/`
`652`	`619`	`private void reportRemoval(String filename)`
`653`	`620`	`{`
`654`		`- Iterator<Listener> itor = _listeners.iterator();`
`655`		`- while (itor.hasNext())`
	`621`	`+ for (Object l : _listeners)`
`656`	`622`	`{`
`657`		`- Object l = itor.next();`
`658`	`623`	`try`
`659`	`624`	`{`
`660`	`625`	`if (l instanceof DiscreteListener)`
`661`	`626`	`((DiscreteListener)l).fileRemoved(filename);`
`662`	`627`	`}`
`663`		`- catch (Exception e)`
`664`		`- {`
`665`		`- warn(l, filename, e);`
`666`		`- }`
`667`		`- catch (Error e)`
	`628`	`+ catch (Throwable e)`
`668`	`629`	`{`
`669`	`630`	`warn(l, filename, e);`
`670`	`631`	`}`
`@@ -678,20 +639,14 @@ private void reportRemoval(String filename)`
`678`	`639`	`*/`
`679`	`640`	`private void reportChange(String filename)`
`680`	`641`	`{`
`681`		`- Iterator<Listener> itor = _listeners.iterator();`
`682`		`- while (itor.hasNext())`
	`642`	`+ for (Listener l : _listeners)`
`683`	`643`	`{`
`684`		`- Listener l = itor.next();`
`685`	`644`	`try`
`686`	`645`	`{`
`687`	`646`	`if (l instanceof DiscreteListener)`
`688`	`647`	`((DiscreteListener)l).fileChanged(filename);`
`689`	`648`	`}`
`690`		`- catch (Exception e)`
`691`		`- {`
`692`		`- warn(l, filename, e);`
`693`		`- }`
`694`		`- catch (Error e)`
	`649`	`+ catch (Throwable e)`
`695`	`650`	`{`
`696`	`651`	`warn(l, filename, e);`
`697`	`652`	`}`
`@@ -700,20 +655,14 @@ private void reportChange(String filename)`
`700`	`655`
`701`	`656`	`private void reportBulkChanges(List<String> filenames)`
`702`	`657`	`{`
`703`		`- Iterator<Listener> itor = _listeners.iterator();`
`704`		`- while (itor.hasNext())`
	`658`	`+ for (Listener l : _listeners)`
`705`	`659`	`{`
`706`		`- Listener l = itor.next();`
`707`	`660`	`try`
`708`	`661`	`{`
`709`	`662`	`if (l instanceof BulkListener)`
`710`	`663`	`((BulkListener)l).filesChanged(filenames);`
`711`	`664`	`}`
`712`		`- catch (Exception e)`
`713`		`- {`
`714`		`- warn(l, filenames.toString(), e);`
`715`		`- }`
`716`		`- catch (Error e)`
	`665`	`+ catch (Throwable e)`
`717`	`666`	`{`
`718`	`667`	`warn(l, filenames.toString(), e);`
`719`	`668`	`}`