--- /dev/null
+//
+// ========================================================================
+// Copyright (c) 1995-2014 Mort Bay Consulting Pty. Ltd.
+// ------------------------------------------------------------------------
+// All rights reserved. This program and the accompanying materials
+// are made available under the terms of the Eclipse Public License v1.0
+// and Apache License v2.0 which accompanies this distribution.
+//
+// The Eclipse Public License is available at
+// http://www.eclipse.org/legal/epl-v10.html
+//
+// The Apache License v2.0 is available at
+// http://www.opensource.org/licenses/apache2.0.php
+//
+// You may elect to redistribute this code under either of these licenses.
+// ========================================================================
+//
+
+package org.eclipse.jetty.server;
+
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.concurrent.Executor;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicBoolean;
+
+import org.eclipse.jetty.io.EndPoint;
+import org.eclipse.jetty.util.annotation.ManagedAttribute;
+import org.eclipse.jetty.util.annotation.ManagedObject;
+import org.eclipse.jetty.util.annotation.Name;
+import org.eclipse.jetty.util.component.AbstractLifeCycle;
+import org.eclipse.jetty.util.log.Log;
+import org.eclipse.jetty.util.log.Logger;
+import org.eclipse.jetty.util.thread.ScheduledExecutorScheduler;
+import org.eclipse.jetty.util.thread.Scheduler;
+import org.eclipse.jetty.util.thread.ThreadPool;
+
+
+/* ------------------------------------------------------------ */
+/** A monitor for low resources
+ * <p>An instance of this class will monitor all the connectors of a server (or a set of connectors
+ * configured with {@link #setMonitoredConnectors(Collection)}) for a low resources state.
+ * Low resources can be detected by:<ul>
+ * <li>{@link ThreadPool#isLowOnThreads()} if {@link Connector#getExecutor()} is
+ * an instance of {@link ThreadPool} and {@link #setMonitorThreads(boolean)} is true.<li>
+ * <li>If {@link #setMaxMemory(long)} is non zero then low resources is detected if the JVMs
+ * {@link Runtime} instance has {@link Runtime#totalMemory()} minus {@link Runtime#freeMemory()}
+ * greater than {@link #getMaxMemory()}</li>
+ * <li>If {@link #setMaxConnections(int)} is non zero then low resources is dected if the total number
+ * of connections exceeds {@link #getMaxConnections()}</li>
+ * </ul>
+ * </p>
+ * <p>Once low resources state is detected, the cause is logged and all existing connections returned
+ * by {@link Connector#getConnectedEndPoints()} have {@link EndPoint#setIdleTimeout(long)} set
+ * to {@link #getLowResourcesIdleTimeout()}. New connections are not affected, however if the low
+ * resources state persists for more than {@link #getMaxLowResourcesTime()}, then the
+ * {@link #getLowResourcesIdleTimeout()} to all connections again. Once the low resources state is
+ * cleared, the idle timeout is reset to the connector default given by {@link Connector#getIdleTimeout()}.
+ * </p>
+ */
+@ManagedObject ("Monitor for low resource conditions and activate a low resource mode if detected")
+public class LowResourceMonitor extends AbstractLifeCycle
+{
+ private static final Logger LOG = Log.getLogger(LowResourceMonitor.class);
+ private final Server _server;
+ private Scheduler _scheduler;
+ private Connector[] _monitoredConnectors;
+ private int _period=1000;
+ private int _maxConnections;
+ private long _maxMemory;
+ private int _lowResourcesIdleTimeout=1000;
+ private int _maxLowResourcesTime=0;
+ private boolean _monitorThreads=true;
+ private final AtomicBoolean _low = new AtomicBoolean();
+ private String _cause;
+ private String _reasons;
+ private long _lowStarted;
+
+
+ private final Runnable _monitor = new Runnable()
+ {
+ @Override
+ public void run()
+ {
+ if (isRunning())
+ {
+ monitor();
+ _scheduler.schedule(_monitor,_period,TimeUnit.MILLISECONDS);
+ }
+ }
+ };
+
+ public LowResourceMonitor(@Name("server") Server server)
+ {
+ _server=server;
+ }
+
+ @ManagedAttribute("Are the monitored connectors low on resources?")
+ public boolean isLowOnResources()
+ {
+ return _low.get();
+ }
+
+ @ManagedAttribute("The reason(s) the monitored connectors are low on resources")
+ public String getLowResourcesReasons()
+ {
+ return _reasons;
+ }
+
+ @ManagedAttribute("Get the timestamp in ms since epoch that low resources state started")
+ public long getLowResourcesStarted()
+ {
+ return _lowStarted;
+ }
+
+ @ManagedAttribute("The monitored connectors. If null then all server connectors are monitored")
+ public Collection<Connector> getMonitoredConnectors()
+ {
+ if (_monitoredConnectors==null)
+ return Collections.emptyList();
+ return Arrays.asList(_monitoredConnectors);
+ }
+
+ /**
+ * @param monitoredConnectors The collections of Connectors that should be monitored for low resources.
+ */
+ public void setMonitoredConnectors(Collection<Connector> monitoredConnectors)
+ {
+ if (monitoredConnectors==null || monitoredConnectors.size()==0)
+ _monitoredConnectors=null;
+ else
+ _monitoredConnectors = monitoredConnectors.toArray(new Connector[monitoredConnectors.size()]);
+ }
+
+ @ManagedAttribute("The monitor period in ms")
+ public int getPeriod()
+ {
+ return _period;
+ }
+
+ /**
+ * @param periodMS The period in ms to monitor for low resources
+ */
+ public void setPeriod(int periodMS)
+ {
+ _period = periodMS;
+ }
+
+ @ManagedAttribute("True if low available threads status is monitored")
+ public boolean getMonitorThreads()
+ {
+ return _monitorThreads;
+ }
+
+ /**
+ * @param monitorThreads If true, check connectors executors to see if they are
+ * {@link ThreadPool} instances that are low on threads.
+ */
+ public void setMonitorThreads(boolean monitorThreads)
+ {
+ _monitorThreads = monitorThreads;
+ }
+
+ @ManagedAttribute("The maximum connections allowed for the monitored connectors before low resource handling is activated")
+ public int getMaxConnections()
+ {
+ return _maxConnections;
+ }
+
+ /**
+ * @param maxConnections The maximum connections before low resources state is triggered
+ */
+ public void setMaxConnections(int maxConnections)
+ {
+ _maxConnections = maxConnections;
+ }
+
+ @ManagedAttribute("The maximum memory (in bytes) that can be used before low resources is triggered. Memory used is calculated as (totalMemory-freeMemory).")
+ public long getMaxMemory()
+ {
+ return _maxMemory;
+ }
+
+ /**
+ * @param maxMemoryBytes The maximum memory in bytes in use before low resources is triggered.
+ */
+ public void setMaxMemory(long maxMemoryBytes)
+ {
+ _maxMemory = maxMemoryBytes;
+ }
+
+ @ManagedAttribute("The idletimeout in ms to apply to all existing connections when low resources is detected")
+ public int getLowResourcesIdleTimeout()
+ {
+ return _lowResourcesIdleTimeout;
+ }
+
+ /**
+ * @param lowResourcesIdleTimeoutMS The timeout in ms to apply to EndPoints when in the low resources state.
+ */
+ public void setLowResourcesIdleTimeout(int lowResourcesIdleTimeoutMS)
+ {
+ _lowResourcesIdleTimeout = lowResourcesIdleTimeoutMS;
+ }
+
+ @ManagedAttribute("The maximum time in ms that low resources condition can persist before lowResourcesIdleTimeout is applied to new connections as well as existing connections")
+ public int getMaxLowResourcesTime()
+ {
+ return _maxLowResourcesTime;
+ }
+
+ /**
+ * @param maxLowResourcesTimeMS The time in milliseconds that a low resource state can persist before the low resource idle timeout is reapplied to all connections
+ */
+ public void setMaxLowResourcesTime(int maxLowResourcesTimeMS)
+ {
+ _maxLowResourcesTime = maxLowResourcesTimeMS;
+ }
+
+ @Override
+ protected void doStart() throws Exception
+ {
+ _scheduler = _server.getBean(Scheduler.class);
+
+ if (_scheduler==null)
+ {
+ _scheduler=new LRMScheduler();
+ _scheduler.start();
+ }
+ super.doStart();
+
+ _scheduler.schedule(_monitor,_period,TimeUnit.MILLISECONDS);
+ }
+
+ @Override
+ protected void doStop() throws Exception
+ {
+ if (_scheduler instanceof LRMScheduler)
+ _scheduler.stop();
+ super.doStop();
+ }
+
+ protected Connector[] getMonitoredOrServerConnectors()
+ {
+ if (_monitoredConnectors!=null && _monitoredConnectors.length>0)
+ return _monitoredConnectors;
+ return _server.getConnectors();
+ }
+
+ protected void monitor()
+ {
+ String reasons=null;
+ String cause="";
+ int connections=0;
+
+ for(Connector connector : getMonitoredOrServerConnectors())
+ {
+ connections+=connector.getConnectedEndPoints().size();
+
+ Executor executor = connector.getExecutor();
+ if (executor instanceof ThreadPool)
+ {
+ ThreadPool threadpool=(ThreadPool) executor;
+ if (_monitorThreads && threadpool.isLowOnThreads())
+ {
+ reasons=low(reasons,"Low on threads: "+threadpool);
+ cause+="T";
+ }
+ }
+ }
+
+ if (_maxConnections>0 && connections>_maxConnections)
+ {
+ reasons=low(reasons,"Max Connections exceeded: "+connections+">"+_maxConnections);
+ cause+="C";
+ }
+
+ long memory=Runtime.getRuntime().totalMemory()-Runtime.getRuntime().freeMemory();
+ if (_maxMemory>0 && memory>_maxMemory)
+ {
+ reasons=low(reasons,"Max memory exceeded: "+memory+">"+_maxMemory);
+ cause+="M";
+ }
+
+
+ if (reasons!=null)
+ {
+ // Log the reasons if there is any change in the cause
+ if (!cause.equals(_cause))
+ {
+ LOG.warn("Low Resources: {}",reasons);
+ _cause=cause;
+ }
+
+ // Enter low resources state?
+ if (_low.compareAndSet(false,true))
+ {
+ _reasons=reasons;
+ _lowStarted=System.currentTimeMillis();
+ setLowResources();
+ }
+
+ // Too long in low resources state?
+ if (_maxLowResourcesTime>0 && (System.currentTimeMillis()-_lowStarted)>_maxLowResourcesTime)
+ setLowResources();
+ }
+ else
+ {
+ if (_low.compareAndSet(true,false))
+ {
+ LOG.info("Low Resources cleared");
+ _reasons=null;
+ _lowStarted=0;
+ _cause=null;
+ clearLowResources();
+ }
+ }
+ }
+
+ protected void setLowResources()
+ {
+ for(Connector connector : getMonitoredOrServerConnectors())
+ {
+ for (EndPoint endPoint : connector.getConnectedEndPoints())
+ endPoint.setIdleTimeout(_lowResourcesIdleTimeout);
+ }
+ }
+
+ protected void clearLowResources()
+ {
+ for(Connector connector : getMonitoredOrServerConnectors())
+ {
+ for (EndPoint endPoint : connector.getConnectedEndPoints())
+ endPoint.setIdleTimeout(connector.getIdleTimeout());
+ }
+ }
+
+ private String low(String reasons, String newReason)
+ {
+ if (reasons==null)
+ return newReason;
+ return reasons+", "+newReason;
+ }
+
+
+ private static class LRMScheduler extends ScheduledExecutorScheduler
+ {
+ }
+}
projects / gigi.git / blobdiff