001/*
002 * Copyright 2015-2017 UnboundID Corp.
003 * All Rights Reserved.
004 */
005/*
006 * Copyright (C) 2015-2017 UnboundID Corp.
007 *
008 * This program is free software; you can redistribute it and/or modify
009 * it under the terms of the GNU General Public License (GPLv2 only)
010 * or the terms of the GNU Lesser General Public License (LGPLv2.1 only)
011 * as published by the Free Software Foundation.
012 *
013 * This program is distributed in the hope that it will be useful,
014 * but WITHOUT ANY WARRANTY; without even the implied warranty of
015 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
016 * GNU General Public License for more details.
017 *
018 * You should have received a copy of the GNU General Public License
019 * along with this program; if not, see <http://www.gnu.org/licenses>.
020 */
021package com.unboundid.ldap.sdk;
022
023
024
025import java.util.ArrayList;
026import java.util.Collection;
027import java.util.Collections;
028import java.util.Iterator;
029import java.util.List;
030
031import com.unboundid.util.StaticUtils;
032import com.unboundid.util.ThreadSafety;
033import com.unboundid.util.ThreadSafetyLevel;
034
035
036
037/**
038 * This class provides an {@link LDAPConnectionPoolHealthCheck} implementation
039 * that may be used to invoke a series of subordinate health checks and ensure
040 * that all of them consider a connection valid before indicating that the
041 * connection is valid.  If any of the subordinate health checks indicates that
042 * the connection is invalid, then the connection will be considered invalid.
043 */
044@ThreadSafety(level=ThreadSafetyLevel.COMPLETELY_THREADSAFE)
045public final class AggregateLDAPConnectionPoolHealthCheck
046       extends LDAPConnectionPoolHealthCheck
047{
048  // The list of subordinate health checks that will be invoked.
049  private final List<LDAPConnectionPoolHealthCheck> healthChecks;
050
051
052
053  /**
054   * Creates a new instance of this LDAP connection pool health check.
055   *
056   * @param  healthChecks  The set of health checks that must all be satisfied
057   *                       in order to consider a connection valid.
058   */
059  public AggregateLDAPConnectionPoolHealthCheck(
060              final LDAPConnectionPoolHealthCheck... healthChecks)
061  {
062    this(StaticUtils.toList(healthChecks));
063  }
064
065
066
067  /**
068   * Creates a new instance of this LDAP connection pool health check.
069   *
070   * @param  healthChecks  The set of health checks that must all be satisfied
071   *                       in order to consider a connection valid.
072   */
073  public AggregateLDAPConnectionPoolHealthCheck(
074       final Collection<? extends LDAPConnectionPoolHealthCheck> healthChecks)
075  {
076    if (healthChecks == null)
077    {
078      this.healthChecks = Collections.emptyList();
079    }
080    else
081    {
082      this.healthChecks = Collections.unmodifiableList(
083           new ArrayList<LDAPConnectionPoolHealthCheck>(healthChecks));
084    }
085  }
086
087
088
089  /**
090   * {@inheritDoc}
091   */
092  @Override()
093  public void ensureNewConnectionValid(final LDAPConnection connection)
094         throws LDAPException
095  {
096    for (final LDAPConnectionPoolHealthCheck hc : healthChecks)
097    {
098      hc.ensureNewConnectionValid(connection);
099    }
100  }
101
102
103
104  /**
105   * {@inheritDoc}
106   */
107  @Override()
108  public void ensureConnectionValidAfterAuthentication(
109                   final LDAPConnection connection,
110                   final BindResult bindResult)
111         throws LDAPException
112  {
113    for (final LDAPConnectionPoolHealthCheck hc : healthChecks)
114    {
115      hc.ensureConnectionValidAfterAuthentication(connection, bindResult);
116    }
117  }
118
119
120
121  /**
122   * {@inheritDoc}
123   */
124  @Override()
125  public void ensureConnectionValidForCheckout(final LDAPConnection connection)
126         throws LDAPException
127  {
128    for (final LDAPConnectionPoolHealthCheck hc : healthChecks)
129    {
130      hc.ensureConnectionValidForCheckout(connection);
131    }
132  }
133
134
135
136  /**
137   * {@inheritDoc}
138   */
139  @Override()
140  public void ensureConnectionValidForRelease(final LDAPConnection connection)
141         throws LDAPException
142  {
143    for (final LDAPConnectionPoolHealthCheck hc : healthChecks)
144    {
145      hc.ensureConnectionValidForRelease(connection);
146    }
147  }
148
149
150
151  /**
152   * {@inheritDoc}
153   */
154  @Override()
155  public void ensureConnectionValidForContinuedUse(
156                   final LDAPConnection connection)
157         throws LDAPException
158  {
159    for (final LDAPConnectionPoolHealthCheck hc : healthChecks)
160    {
161      hc.ensureConnectionValidForContinuedUse(connection);
162    }
163  }
164
165
166
167  /**
168   * {@inheritDoc}
169   */
170  @Override()
171  public void ensureConnectionValidAfterException(
172                   final LDAPConnection connection,
173                   final LDAPException exception)
174         throws LDAPException
175  {
176    for (final LDAPConnectionPoolHealthCheck hc : healthChecks)
177    {
178      hc.ensureConnectionValidAfterException(connection, exception);
179    }
180  }
181
182
183
184  /**
185   * {@inheritDoc}
186   */
187  @Override()
188  public void toString(final StringBuilder buffer)
189  {
190    buffer.append("AggregateLDAPConnectionPoolHealthCheck(healthChecks={");
191
192    final Iterator<LDAPConnectionPoolHealthCheck> iterator =
193         healthChecks.iterator();
194    while (iterator.hasNext())
195    {
196      iterator.next().toString(buffer);
197      if (iterator.hasNext())
198      {
199        buffer.append(", ");
200      }
201    }
202
203    buffer.append("})");
204  }
205}