Merge branch 'jetty-9' of ssh://git.eclipse.org/gitroot/jetty/org.eclipse.jetty.project into jetty-9

jetty-server/src/main/java/org/eclipse/jetty/server/AbstractConnector.java

@@ -39,7 +39,7 @@ public abstract class AbstractConnector extends AggregateLifeCycle implements Co
     protected final Logger logger = Log.getLogger(getClass());
     // Order is important on server side, so we use a LinkedHashMap
     private final Map<String, ConnectionFactory> factories = new LinkedHashMap<>();
-    private final Statistics _stats = new ConnectionStatistics();
+    private final Statistics _stats = new ConnectorStatistics();
     private final Server _server;
     private final SslContextFactory _sslContextFactory;
     private final Executor _executor;
@@ -83,7 +83,8 @@ public abstract class AbstractConnector extends AggregateLifeCycle implements Co
         addBean(_executor,false);
         addBean(_scheduler,scheduler==null);
         addBean(_byteBufferPool,pool==null);
-        addBean(_sslContextFactory,true);
+        addBean(_sslContextFactory);
+        addBean(_stats,false);
 
         if (acceptors<=0)
             acceptors=Math.max(1,(Runtime.getRuntime().availableProcessors()) / 4);

jetty-server/src/main/java/org/eclipse/jetty/server/ConnectionStatistics.java

@@ -1,241 +0,0 @@
-// ========================================================================
-// Copyright (c) 2004-2012 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.concurrent.atomic.AtomicLong;
-
-import org.eclipse.jetty.server.Connector.Statistics;
-import org.eclipse.jetty.util.component.AbstractLifeCycle;
-import org.eclipse.jetty.util.statistic.CounterStatistic;
-import org.eclipse.jetty.util.statistic.SampleStatistic;
-
-class ConnectionStatistics extends AbstractLifeCycle implements Statistics
-{
-    private final AtomicLong _statsStartedAt = new AtomicLong(-1L);
-    private final CounterStatistic _connectionStats = new CounterStatistic();
-    private final SampleStatistic _messagesIn = new SampleStatistic();
-    private final SampleStatistic _messagesOut = new SampleStatistic();
-    private final SampleStatistic _connectionDurationStats = new SampleStatistic();
-
-
-    /* ------------------------------------------------------------ */
-    @Override
-    public int getBytesIn()
-    {
-        return -1;
-    }
-
-    /* ------------------------------------------------------------ */
-
-    @Override
-    public int getBytesOut()
-    {
-        return -1;
-    }
-
-    /* ------------------------------------------------------------ */
-    /**
-     * @return Number of connections accepted by the server since statsReset() called. Undefined if setStatsOn(false).
-     */
-    @Override
-    public int getConnections()
-    {
-        return (int)_connectionStats.getTotal();
-    }
-
-    /* ------------------------------------------------------------ */
-    /**
-     * @return Maximum duration in milliseconds of an open connection since statsReset() called. Undefined if setStatsOn(false).
-     */
-    @Override
-    public long getConnectionsDurationMax()
-    {
-        return _connectionDurationStats.getMax();
-    }
-
-    /* ------------------------------------------------------------ */
-    /**
-     * @return Mean duration in milliseconds of open connections since statsReset() called. Undefined if setStatsOn(false).
-     */
-    @Override
-    public double getConnectionsDurationMean()
-    {
-        return _connectionDurationStats.getMean();
-    }
-
-    /* ------------------------------------------------------------ */
-    /**
-     * @return Standard deviation of duration in milliseconds of open connections since statsReset() called. Undefined if setStatsOn(false).
-     */
-    @Override
-    public double getConnectionsDurationStdDev()
-    {
-        return _connectionDurationStats.getStdDev();
-    }
-
-    /* ------------------------------------------------------------ */
-    /**
-     * @return Returns the connectionsDurationTotal.
-     */
-    @Override
-    public long getConnectionsDurationTotal()
-    {
-        return _connectionDurationStats.getTotal();
-    }
-
-    /* ------------------------------------------------------------ */
-    /**
-     * @return Maximum number of requests per connection since statsReset() called. Undefined if setStatsOn(false).
-     */
-    @Override
-    public int getConnectionsMessagesInMax()
-    {
-        return (int)_messagesIn.getMax();
-    }
-
-    /* ------------------------------------------------------------ */
-    /**
-     * @return Mean number of requests per connection since statsReset() called. Undefined if setStatsOn(false).
-     */
-    @Override
-    public double getConnectionsMessagesInMean()
-    {
-        return _messagesIn.getMean();
-    }
-
-    /* ------------------------------------------------------------ */
-    /**
-     * @return Standard deviation of number of requests per connection since statsReset() called. Undefined if setStatsOn(false).
-     */
-    @Override
-    public double getConnectionsMessagesInStdDev()
-    {
-        return _messagesIn.getStdDev();
-    }
-
-    /* ------------------------------------------------------------ */
-    /**
-     * @return Number of connections currently open that were opened since statsReset() called. Undefined if setStatsOn(false).
-     */
-    @Override
-    public int getConnectionsOpen()
-    {
-        return (int)_connectionStats.getCurrent();
-    }
-
-    /* ------------------------------------------------------------ */
-    /**
-     * @return Maximum number of connections opened simultaneously since statsReset() called. Undefined if setStatsOn(false).
-     */
-    @Override
-    public int getConnectionsOpenMax()
-    {
-        return (int)_connectionStats.getMax();
-    }
-
-    /* ------------------------------------------------------------ */
-    /**
-     * @return Get the number of requests handled by this connector since last call of statsReset(). If setStatsOn(false) then this is undefined.
-     */
-    @Override
-    public int getMessagesIn()
-    {
-        return (int)_messagesIn.getTotal();
-    }
-
-    /* ------------------------------------------------------------ */
-    /**
-     * @return Get the number of requests handled by this connector since last call of statsReset(). If setStatsOn(false) then this is undefined.
-     */
-    @Override
-    public int getMessagesOut()
-    {
-        return (int)_messagesIn.getTotal();
-    }
-
-    /* ------------------------------------------------------------ */
-    /**
-     * @return True if statistics collection is turned on.
-     */
-    @Override
-    public boolean getStatsOn()
-    {
-        return _statsStartedAt.get() != -1;
-    }
-
-    /* ------------------------------------------------------------ */
-    /**
-     * @return Timestamp stats were started at.
-     */
-    @Override
-    public long getStatsOnMs()
-    {
-        long start = _statsStartedAt.get();
-
-        return (start != -1)?(System.currentTimeMillis() - start):0;
-    }
-
-    /* ------------------------------------------------------------ */
-    @Override
-    public void doStart()
-    {
-        statsReset();
-        _statsStartedAt.set(System.currentTimeMillis());
-    }
-
-    /* ------------------------------------------------------------ */
-    @Override
-    public void doStop()
-    {
-
-    }
-
-    /* ------------------------------------------------------------ */
-    /**
-     * Reset statistics.
-     */
-    @Override
-    public void statsReset()
-    {
-        _messagesIn.reset();
-        _connectionStats.reset();
-        _connectionDurationStats.reset();
-    }
-
-    /* ------------------------------------------------------------ */
-    @Override
-    public void connectionOpened()
-    {
-        if (isStarted())
-            _connectionStats.increment();
-    }
-
-    /* ------------------------------------------------------------ */
-    @Override
-    public void connectionUpgraded(long duration, int messagesIn, int messagesOut)
-    {
-        _messagesIn.set(messagesIn);
-        _messagesOut.set(messagesOut);
-    }
-
-    /* ------------------------------------------------------------ */
-    @Override
-    public void connectionClosed(long duration, int messagesIn, int messagesOut)
-    {
-        _messagesIn.set(messagesIn);
-        _messagesOut.set(messagesOut);
-        _connectionStats.decrement();
-        _connectionDurationStats.set(duration);
-    }
-}

jetty-server/src/main/java/org/eclipse/jetty/server/Connector.java

@@ -77,104 +77,99 @@ public interface Connector extends LifeCycle
      */
     public interface Statistics extends LifeCycle
     {
-        /**
-         * @return true if gathering of statistics is enabled
-         */
-        public boolean getStatsOn();
-
         /**
          * <p>Resets the statistics.</p>
          */
-        public void statsReset();
+        public void reset();
 
         /**
          * @return the number of messages received by this connector
-         * since last call to {@link #statsReset()}.
+         * since last call to {@link #reset}.
          */
         public int getMessagesIn();
 
         /**
          * @return the number of messages sent by this connector
-         * since last call to {@link #statsReset()}.
+         * since last call to {@link #reset}.
          */
         public int getMessagesOut();
 
         /**
          * @return the number of bytes received by this connector
-         * since last call to {@link #statsReset()}.
+         * since last call to {@link #reset}.
          */
         public int getBytesIn();
 
         /**
          * @return the number of bytes sent by this connector
-         * since last call to {@link #statsReset()}.
+         * since last call to {@link #reset}.
          */
         public int getBytesOut();
 
         /**
          * @return the total time connections have been open, in milliseconds,
-         * since last call to {@link #statsReset()}.
+         * since last call to {@link #reset}.
          */
         public long getConnectionsDurationTotal();
 
         /**
          * @return the number of connections accepted by the server
-         * since last call to {@link #statsReset()}.
+         * since last call to {@link #reset}.
          */
         public int getConnections() ;
 
         /**
          * @return the number of connections currently open that were opened
-         * since last call to {@link #statsReset()}.
+         * since last call to {@link #reset}.
          */
         public int getConnectionsOpen() ;
 
         /**
          * @return the max number of connections opened simultaneously
-         * since last call to {@link #statsReset()}.
+         * since last call to {@link #reset}.
          */
         public int getConnectionsOpenMax() ;
 
         /**
          * @return the max time a connection has been open, in milliseconds,
-         * since last call to {@link #statsReset()}.
+         * since last call to {@link #reset}.
          */
         public long getConnectionsDurationMax();
 
         /**
          * @return the mean time connections have been open, in milliseconds,
-         * since last call to {@link #statsReset()}.
+         * since last call to {@link #reset}.
          */
         public double getConnectionsDurationMean() ;
 
         /**
          * @return the standard deviation of the time connections have been open, in milliseconds,
-         * since last call to {@link #statsReset()}.
+         * since last call to {@link #reset}.
          */
         public double getConnectionsDurationStdDev() ;
 
         /**
          * @return the mean number of messages received per connection
-         * since last call to {@link #statsReset()}.
+         * since last call to {@link #reset}.
          */
         public double getConnectionsMessagesInMean() ;
 
         /**
          * @return the standard deviation of the number of messages received per connection
-         * since last call to {@link #statsReset()}.
+         * since last call to {@link #reset}.
          */
         public double getConnectionsMessagesInStdDev() ;
 
         /**
          * @return the max number of messages received by a connection
-         * since last call to {@link #statsReset()}.
+         * since last call to {@link #reset}.
          */
         public int getConnectionsMessagesInMax();
 
         /**
          * @return the number of milliseconds the statistics have been started or reset
          */
-        public long getStatsOnMs();
+        public long getStartedMillis();
 
         /**
          * <p>Callback method invoked when a new connection is opened.</p>

jetty-server/src/main/java/org/eclipse/jetty/server/ConnectorStatistics.java

@@ -0,0 +1,175 @@
+// ========================================================================
+// Copyright (c) 2004-2012 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.concurrent.atomic.AtomicLong;
+
+import org.eclipse.jetty.server.Connector.Statistics;
+import org.eclipse.jetty.util.component.AbstractLifeCycle;
+import org.eclipse.jetty.util.statistic.CounterStatistic;
+import org.eclipse.jetty.util.statistic.SampleStatistic;
+
+class ConnectorStatistics extends AbstractLifeCycle implements Statistics
+{
+    private final AtomicLong _startMillis = new AtomicLong(-1L);
+    private final CounterStatistic _connectionStats = new CounterStatistic();
+    private final SampleStatistic _messagesIn = new SampleStatistic();
+    private final SampleStatistic _messagesOut = new SampleStatistic();
+    private final SampleStatistic _connectionDurationStats = new SampleStatistic();
+
+    @Override
+    public int getBytesIn()
+    {
+        // TODO
+        return -1;
+    }
+
+    @Override
+    public int getBytesOut()
+    {
+        // TODO
+        return -1;
+    }
+
+    @Override
+    public int getConnections()
+    {
+        return (int)_connectionStats.getTotal();
+    }
+
+    @Override
+    public long getConnectionsDurationMax()
+    {
+        return _connectionDurationStats.getMax();
+    }
+
+    @Override
+    public double getConnectionsDurationMean()
+    {
+        return _connectionDurationStats.getMean();
+    }
+
+    @Override
+    public double getConnectionsDurationStdDev()
+    {
+        return _connectionDurationStats.getStdDev();
+    }
+
+    @Override
+    public long getConnectionsDurationTotal()
+    {
+        return _connectionDurationStats.getTotal();
+    }
+
+    @Override
+    public int getConnectionsMessagesInMax()
+    {
+        return (int)_messagesIn.getMax();
+    }
+
+    @Override
+    public double getConnectionsMessagesInMean()
+    {
+        return _messagesIn.getMean();
+    }
+
+    @Override
+    public double getConnectionsMessagesInStdDev()
+    {
+        return _messagesIn.getStdDev();
+    }
+
+    @Override
+    public int getConnectionsOpen()
+    {
+        return (int)_connectionStats.getCurrent();
+    }
+
+    @Override
+    public int getConnectionsOpenMax()
+    {
+        return (int)_connectionStats.getMax();
+    }
+
+    @Override
+    public int getMessagesIn()
+    {
+        return (int)_messagesIn.getTotal();
+    }
+
+    @Override
+    public int getMessagesOut()
+    {
+        return (int)_messagesIn.getTotal();
+    }
+
+    @Override
+    public long getStartedMillis()
+    {
+        long start = _startMillis.get();
+        return start < 0 ? 0 : System.currentTimeMillis() - start;
+    }
+
+    @Override
+    public void doStart()
+    {
+        reset();
+    }
+
+    @Override
+    public void doStop()
+    {
+    }
+
+    @Override
+    public void reset()
+    {
+        _startMillis.set(System.currentTimeMillis());
+        _messagesIn.reset();
+        _messagesOut.reset();
+        _connectionStats.reset();
+        _connectionDurationStats.reset();
+    }
+
+    @Override
+    public void connectionOpened()
+    {
+        if (isStarted())
+        {
+            _connectionStats.increment();
+        }
+    }
+
+    @Override
+    public void connectionUpgraded(long duration, int messagesIn, int messagesOut)
+    {
+        if (isStarted())
+        {
+            _messagesIn.set(messagesIn);
+            _messagesOut.set(messagesOut);
+        }
+    }
+
+    @Override
+    public void connectionClosed(long duration, int messagesIn, int messagesOut)
+    {
+        if (isStarted())
+        {
+            _messagesIn.set(messagesIn);
+            _messagesOut.set(messagesOut);
+            _connectionStats.decrement();
+            _connectionDurationStats.set(duration);
+        }
+    }
+}

jetty-server/src/main/java/org/eclipse/jetty/server/LocalConnector.java

@@ -150,8 +150,8 @@ public class LocalConnector extends AbstractConnector
         Connection connection = getDefaultConnectionFactory().newConnection(null, endp, null);
         endp.setConnection(connection);
         endp.onOpen();
-        connection.onOpen();
         connectionOpened(connection);
+        connection.onOpen();
     }
 
     public class LocalEndPoint extends ByteArrayEndPoint

jetty-server/src/main/java/org/eclipse/jetty/server/SelectChannelConnector.java

@@ -291,8 +291,8 @@ public class SelectChannelConnector extends AbstractNetworkConnector
         @Override
         public void connectionOpened(Connection connection)
         {
-            super.connectionOpened(connection);
             SelectChannelConnector.this.connectionOpened(connection);
+            super.connectionOpened(connection);
         }
 
         @Override
@@ -305,8 +305,8 @@ public class SelectChannelConnector extends AbstractNetworkConnector
         @Override
         public void connectionUpgraded(EndPoint endpoint, Connection oldConnection)
         {
-            super.connectionUpgraded(endpoint, oldConnection);
             SelectChannelConnector.this.connectionUpgraded(oldConnection, endpoint.getConnection());
+            super.connectionUpgraded(endpoint, oldConnection);
         }
 
         @Override

jetty-util/src/main/java/org/eclipse/jetty/util/component/AggregateLifeCycle.java

@@ -1,22 +1,22 @@
+// ========================================================================
+// Copyright (c) 2006-2012 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.util.component;
-//========================================================================
-//Copyright (c) 2006-2012 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. 
-//========================================================================
 
 import java.io.IOException;
 import java.util.ArrayList;
 import java.util.Collection;
 import java.util.Collections;
-import java.util.Iterator;
 import java.util.List;
 import java.util.concurrent.CopyOnWriteArrayList;
 
@@ -25,110 +25,102 @@ import org.eclipse.jetty.util.log.Logger;
 
 /**
  * An AggregateLifeCycle is an {@link LifeCycle} implementation for a collection of contained beans.
- * <p>
+ * <p/>
  * Beans can be added the AggregateLifeCycle either as managed beans or as unmanaged beans.  A managed bean is started, stopped and destroyed with the aggregate.
  * An unmanaged bean is associated with the aggregate for the purposes of {@link #dump()}, but it's lifecycle must be managed externally.
- * <p>
+ * <p/>
  * When a bean is added, if it is a {@link LifeCycle} and it is already started, then it is assumed to be an unmanaged bean.
  * Otherwise the methods {@link #addBean(Object, boolean)}, {@link #manage(Object)} and {@link #unmanage(Object)} can be used to
  * explicitly control the life cycle relationship.
- * <p>
+ * <p/>
  * If adding a bean that is shared between multiple {@link AggregateLifeCycle} instances, then it should be started before being added, so it is unmanaged, or
  * the API must be used to explicitly set it as unmanaged.
- * <p>
+ * <p/>
  */
 public class AggregateLifeCycle extends AbstractLifeCycle implements Destroyable, Dumpable
 {
     private static final Logger LOG = Log.getLogger(AggregateLifeCycle.class);
-    private final List<Bean> _beans=new CopyOnWriteArrayList<Bean>();
+    private final List<Bean> _beans = new CopyOnWriteArrayList<>();
-    private boolean _started=false;
+    private boolean _started = false;
 
     private class Bean
     {
-        Bean(Object b) 
+        private final Object _bean;
+        private volatile boolean _managed = true;
+
+        private Bean(Object b)
         {
-            _bean=b;
+            _bean = b;
         }
-        final Object _bean;
-        volatile boolean _managed=true;
 
         public String toString()
         {
-            return "{"+_bean+","+_managed+"}";
+            return String.format("{%s,%b}", _bean, _managed);
         }
     }
 
-    /* ------------------------------------------------------------ */
     /**
-     * Start the managed lifecycle beans in the order they were added.
+     * Starts the managed lifecycle beans in the order they were added.
-     * @see org.eclipse.jetty.util.component.AbstractLifeCycle#doStart()
      */
     @Override
     protected void doStart() throws Exception
     {
-        for (Bean b:_beans)
+        for (Bean b : _beans)
         {
             if (b._bean instanceof LifeCycle)
             {
-                LifeCycle l=(LifeCycle)b._bean;
+                LifeCycle l = (LifeCycle)b._bean;
                 if (!l.isRunning())
                 {
                     if (b._managed)
                         l.start();
-                    else
-                        LOG.warn("!managed !started {}",b);
                 }
             }
             if (b._managed && b._bean instanceof LifeCycle)
             {
-                LifeCycle l=(LifeCycle)b._bean;
+                LifeCycle l = (LifeCycle)b._bean;
                 if (!l.isRunning())
                     l.start();
             }
         }
         // indicate that we are started, so that addBean will start other beans added.
-        _started=true;
+        _started = true;
         super.doStart();
     }
 
-    /* ------------------------------------------------------------ */
     /**
-     * Stop the joined lifecycle beans in the reverse order they were added.
+     * Stops the managed lifecycle beans in the reverse order they were added.
-     * @see org.eclipse.jetty.util.component.AbstractLifeCycle#doStart()
      */
     @Override
     protected void doStop() throws Exception
     {
-        _started=false;
+        _started = false;
         super.doStop();
-        List<Bean> reverse = new ArrayList<Bean>(_beans);
+        List<Bean> reverse = new ArrayList<>(_beans);
         Collections.reverse(reverse);
-        for (Bean b:reverse)
+        for (Bean b : reverse)
         {
             if (b._managed && b._bean instanceof LifeCycle)
             {
-                LifeCycle l=(LifeCycle)b._bean;
+                LifeCycle l = (LifeCycle)b._bean;
                 if (l.isRunning())
                     l.stop();
             }
         }
     }
 
-
-    /* ------------------------------------------------------------ */
     /**
-     * Destroy the joined Destroyable beans in the reverse order they were added.
+     * Destroys the managed Destroyable beans in the reverse order they were added.
-     * @see org.eclipse.jetty.util.component.Destroyable#destroy()
      */
     public void destroy()
     {
-        List<Bean> reverse = new ArrayList<Bean>(_beans);
+        List<Bean> reverse = new ArrayList<>(_beans);
         Collections.reverse(reverse);
-        for (Bean b:reverse)
+        for (Bean b : reverse)
         {
             if (b._bean instanceof Destroyable && b._managed)
             {
-                Destroyable d=(Destroyable)b._bean;
+                Destroyable d = (Destroyable)b._bean;
                 d.destroy();
             }
         }
@@ -136,53 +128,54 @@ public class AggregateLifeCycle extends AbstractLifeCycle implements Destroyable
     }
 
 
-    /* ------------------------------------------------------------ */
+
-    /** Is the bean contained in the aggregate.
+    /**
-     * @param bean
+     * @param bean the bean to test
-     * @return True if the aggregate contains the bean
+     * @return whether this aggregate contains the bean
      */
     public boolean contains(Object bean)
     {
-        for (Bean b:_beans)
+        for (Bean b : _beans)
-            if (b._bean==bean)
+            if (b._bean == bean)
                 return true;
         return false;
     }
 
-    /* ------------------------------------------------------------ */
+    /**
-    /** Is the bean joined to the aggregate.
+     * @param bean the bean to test
-     * @param bean
+     * @return whether this aggregate contains and manages the bean
-     * @return True if the aggregate contains the bean and it is joined
      */
     public boolean isManaged(Object bean)
     {
-        for (Bean b:_beans)
+        for (Bean b : _beans)
-            if (b._bean==bean)
+            if (b._bean == bean)
                 return b._managed;
         return false;
     }
 
-    /* ------------------------------------------------------------ */
     /**
-     * Add an associated bean.
+     * Adds the given bean, detecting whether to manage it or not.
      * If the bean is a {@link LifeCycle}, then it will be managed if it is not
-     * already started and umanaged if it is already started. The {@link #addBean(Object, boolean)}
+     * already started and not managed if it is already started.
+     * The {@link #addBean(Object, boolean)}
      * method should be used if this is not correct, or the {@link #manage(Object)} and {@link #unmanage(Object)}
      * methods may be used after an add to change the status.
+     *
      * @param o the bean object to add
-     * @return true if the bean was added or false if it has already been added.
+     * @return true if the bean was added, false if it was already present
      */
     public boolean addBean(Object o)
     {
         // beans are joined unless they are started lifecycles
-        return addBean(o,!((o instanceof LifeCycle)&&((LifeCycle)o).isStarted()));
+        return addBean(o, !((o instanceof LifeCycle) && ((LifeCycle)o).isStarted()));
     }
 
-    /* ------------------------------------------------------------ */
+    /**
-    /** Add an associated lifecycle.
+     * Adds the given bean, explicitly managing it or not.
-     * @param o The lifecycle to add
+     *
-     * @param managed True if the LifeCycle is to be joined, otherwise it will be disjoint.
+     * @param o       The bean object to add
-     * @return true if bean was added, false if already present.
+     * @param managed whether to managed the lifecycle of the bean
+     * @return true if the bean was added, false if it was already present
      */
     public boolean addBean(Object o, boolean managed)
     {
@@ -190,12 +183,12 @@ public class AggregateLifeCycle extends AbstractLifeCycle implements Destroyable
             return false;
 
         Bean b = new Bean(o);
-        b._managed=managed;
+        b._managed = managed;
         _beans.add(b);
 
         if (o instanceof LifeCycle)
         {
-            LifeCycle l=(LifeCycle)o;
+            LifeCycle l = (LifeCycle)o;
 
             // Start the bean if we are started
             if (managed && _started)
@@ -204,118 +197,111 @@ public class AggregateLifeCycle extends AbstractLifeCycle implements Destroyable
                 {
                     l.start();
                 }
-                catch(Exception e)
+                catch (Exception e)
                 {
-                    throw new RuntimeException (e);
+                    throw new RuntimeException(e);
                 }
             }
         }
         return true;
     }
 
-    /* ------------------------------------------------------------ */
     /**
-     * Manage a bean by this aggregate, so that it is started/stopped/destroyed with the 
+     * Manages a bean already contained by this aggregate, so that it is started/stopped/destroyed with this
-     * aggregate lifecycle.  
+     * aggregate.
+     *
      * @param bean The bean to manage (must already have been added).
      */
     public void manage(Object bean)
     {
-        for (Bean b :_beans)
+        for (Bean b : _beans)
         {
-            if (b._bean==bean)
+            if (b._bean == bean)
             {
-                b._managed=true;
+                b._managed = true;
                 return;
             }
         }
-        throw new IllegalArgumentException();
+        throw new IllegalArgumentException("Unknown bean " + bean);
     }
 
-    /* ------------------------------------------------------------ */
     /**
-     * Unmanage a bean by this aggregate, so that it is not started/stopped/destroyed with the 
+     * Unmanages a bean already contained by this aggregate, so that it is not started/stopped/destroyed with this
-     * aggregate lifecycle.  
+     * aggregate.
-     * @param bean The bean to manage (must already have been added).
+     *
+     * @param bean The bean to unmanage (must already have been added).
      */
     public void unmanage(Object bean)
     {
-        for (Bean b :_beans)
+        for (Bean b : _beans)
         {
-            if (b._bean==bean)
+            if (b._bean == bean)
             {
-                b._managed=false;
+                b._managed = false;
                 return;
             }
         }
-        throw new IllegalArgumentException();
+        throw new IllegalArgumentException("Unknown bean " + bean);
     }
 
-    /* ------------------------------------------------------------ */
+    /**
-    /** Get dependent beans 
+     * @return the list of beans known to this aggregate
-     * @return List of beans.
+     * @see #getBean(Class)
      */
     public Collection<Object> getBeans()
     {
         return getBeans(Object.class);
     }
 
-    /* ------------------------------------------------------------ */
+    /**
-    /** Get dependent beans of a specific class
+     * @param clazz the class of the beans
-     * @see #addBean(Object)
+     * @return the list of beans of the given class (or subclass)
-     * @param clazz
+     * @see #getBeans()
-     * @return List of beans.
      */
     public <T> List<T> getBeans(Class<T> clazz)
     {
-        ArrayList<T> beans = new ArrayList<T>();
+        ArrayList<T> beans = new ArrayList<>();
-        for (Bean b:_beans)
+        for (Bean b : _beans)
         {
             if (clazz.isInstance(b._bean))
-                beans.add((T)(b._bean));
+                beans.add(clazz.cast(b._bean));
         }
         return beans;
     }
 
-    
+    /**
-    /* ------------------------------------------------------------ */
+     * @param clazz the class of the bean
-    /** Get dependent beans of a specific class.
+     * @return the first bean of a specific class (or subclass), or null if no such bean exist
-     * If more than one bean of the type exist, the first is returned.
-     * @see #addBean(Object)
-     * @param clazz
-     * @return bean or null
      */
     public <T> T getBean(Class<T> clazz)
     {
-        for (Bean b:_beans)
+        for (Bean b : _beans)
         {
             if (clazz.isInstance(b._bean))
-                return (T)b._bean;
+                return clazz.cast(b._bean);
         }
-        
         return null;
     }
 
-    /* ------------------------------------------------------------ */
     /**
-     * Remove all associated bean.
+     * Removes all bean, without performing any lifecycle
+     * @see #destroy()
      */
-    public void removeBeans ()
+    public void removeBeans()
     {
         _beans.clear();
     }
 
-    /* ------------------------------------------------------------ */
     /**
-     * Remove an associated bean.
+     * Removes the given bean.
+     * @return whether the bean was removed
+     * @see #removeBeans()
      */
-    public boolean removeBean (Object o)
+    public boolean removeBean(Object o)
     {
-        Iterator<Bean> i = _beans.iterator();
+        for (Bean b : _beans)
-        while(i.hasNext())
         {
-            Bean b=i.next();
+            if (b._bean == o)
-            if (b._bean==o)
             {
                 _beans.remove(b);
                 return true;
@@ -324,12 +310,15 @@ public class AggregateLifeCycle extends AbstractLifeCycle implements Destroyable
         return false;
     }
 
-    /* ------------------------------------------------------------ */
+    /**
+     * Dumps to {@link System#err}.
+     * @see #dump()
+     */
     public void dumpStdErr()
     {
         try
         {
-            dump(System.err,"");
+            dump(System.err, "");
         }
         catch (IOException e)
         {
@@ -337,19 +326,17 @@ public class AggregateLifeCycle extends AbstractLifeCycle implements Destroyable
         }
     }
 
-    /* ------------------------------------------------------------ */
     public String dump()
     {
         return dump(this);
     }
 
-    /* ------------------------------------------------------------ */
     public static String dump(Dumpable dumpable)
     {
         StringBuilder b = new StringBuilder();
         try
         {
-            dumpable.dump(b,"");
+            dumpable.dump(b, "");
         }
         catch (IOException e)
         {
@@ -358,20 +345,17 @@ public class AggregateLifeCycle extends AbstractLifeCycle implements Destroyable
         return b.toString();
     }
 
-    /* ------------------------------------------------------------ */
     public void dump(Appendable out) throws IOException
     {
-        dump(out,"");
+        dump(out, "");
     }
 
-    /* ------------------------------------------------------------ */
     protected void dumpThis(Appendable out) throws IOException
     {
         out.append(String.valueOf(this)).append(" - ").append(getState()).append("\n");
     }
 
-    /* ------------------------------------------------------------ */
+    public static void dumpObject(Appendable out, Object o) throws IOException
-    public static void dumpObject(Appendable out,Object o) throws IOException
     {
         try
         {
@@ -380,20 +364,19 @@ public class AggregateLifeCycle extends AbstractLifeCycle implements Destroyable
             else
                 out.append(String.valueOf(o)).append("\n");
         }
-        catch(Throwable th)
+        catch (Throwable th)
         {
             out.append(" => ").append(th.toString()).append('\n');
         }
     }
 
-    /* ------------------------------------------------------------ */
+    public void dump(Appendable out, String indent) throws IOException
-    public void dump(Appendable out,String indent) throws IOException
     {
         dumpThis(out);
-        int size=_beans.size();
+        int size = _beans.size();
-        if (size==0)
+        if (size == 0)
             return;
-        int i=0;
+        int i = 0;
         for (Bean b : _beans)
         {
             i++;
@@ -402,33 +385,32 @@ public class AggregateLifeCycle extends AbstractLifeCycle implements Destroyable
             {
                 out.append(indent).append(" +- ");
                 if (b._bean instanceof Dumpable)
-                    ((Dumpable)b._bean).dump(out,indent+(i==size?"    ":" |  "));
+                    ((Dumpable)b._bean).dump(out, indent + (i == size ? "    " : " |  "));
                 else
-                    dumpObject(out,b._bean);
+                    dumpObject(out, b._bean);
             }
             else
             {
                 out.append(indent).append(" +~ ");
-                dumpObject(out,b._bean);
+                dumpObject(out, b._bean);
             }
         }
 
-        if (i!=size)
+        if (i != size)
             out.append(indent).append(" |\n");
     }
 
-    /* ------------------------------------------------------------ */
+    public static void dump(Appendable out, String indent, Collection<?>... collections) throws IOException
-    public static void dump(Appendable out,String indent,Collection<?>... collections) throws IOException
     {
-        if (collections.length==0)
+        if (collections.length == 0)
             return;
-        int size=0;
+        int size = 0;
         for (Collection<?> c : collections)
-            size+=c.size();    
+            size += c.size();
-        if (size==0)
+        if (size == 0)
             return;
 
-        int i=0;
+        int i = 0;
         for (Collection<?> c : collections)
         {
             for (Object o : c)
@@ -437,12 +419,12 @@ public class AggregateLifeCycle extends AbstractLifeCycle implements Destroyable
                 out.append(indent).append(" +- ");
 
                 if (o instanceof Dumpable)
-                    ((Dumpable)o).dump(out,indent+(i==size?"    ":" |  "));
+                    ((Dumpable)o).dump(out, indent + (i == size ? "    " : " |  "));
                 else
-                    dumpObject(out,o);
+                    dumpObject(out, o);
             }
 
-            if (i!=size)
+            if (i != size)
                 out.append(indent).append(" |\n");
         }
     }