if err != nil {
		return err
	}

	for _, target := range targetList {
		defer target.Close()
	}

	for _, target := range targetList {
		yes, err := target.IsActive()
		if err == nil && !yes {
			err = ErrTargetsOffline
		}
		if err != nil {
			return fmt.Errorf("error (%s): %w", target.ID(), err)
		}
	}

	return nil
}

        if (activeProxy == null) {
            java.util.List<Proxy> proxies = getProxies();
            if (proxies != null && !proxies.isEmpty()) {
                for (Proxy proxy : proxies) {
                    if (proxy.isActive()) {
                        activeProxy = proxy;
                        break;
                    }
                }
            }
        }
        return activeProxy;
    }

            if (request != null) {
                List<Proxy> proxies = request.getProxies();

                if (proxies != null) {
                    for (Proxy proxy : proxies) {
                        if (proxy.isActive() && protocol.equalsIgnoreCase(proxy.getProtocol())) {
                            SettingsDecryptionResult result =
                                    settingsDecrypter.decrypt(new DefaultSettingsDecryptionRequest(proxy));

        }
        t.interrupt();
        if (logger.isDebugEnabled()) {
            logger.debug("TimeoutManager stopped.");
        }
        t.join(timeoutMillis);
        return !t.isAlive();
    }

    /**
     * 管理している {@link TimeoutTask}をクリアします。
     */
    public synchronized void clear() {
        timeoutTaskList.clear();
    }

    /**
     * {@link TimeoutTarget}を追加します。

        this.profileActivationFilePathInterpolator = profileActivationFilePathInterpolator;
    }

    @Override
    public boolean isActive(Profile profile, ProfileActivationContext context, ModelProblemCollector problems) {
        Activation activation = profile.getActivation();

        if (activation == null) {
            return false;
        }

        //      <nonProxyHosts>www.google.com|*.somewhere.com</nonProxyHosts>
        //    </proxy>
        //  </proxies>

        for (Proxy proxy : settings.getProxies()) {
            if (!proxy.isActive()) {
                continue;
            }

            request.addProxy(proxy);
        }

        // <mirrors>
        //   <mirror>
        //     <id>nexus</id>

    }

    public int getDepth() {
        return depth;
    }

    public List<ArtifactRepository> getRemoteRepositories() {
        return remoteRepositories;
    }

    public boolean isActive() {
        return active;
    }

    public void enable() {
        active = true;

        // TODO if it was null, we really need to go find them now... or is this taken care of by the ordering?

        //      <nonProxyHosts>www.google.com|*.somewhere.com</nonProxyHosts>
        //    </proxy>
        //  </proxies>

        for (Proxy proxy : settings.getProxies()) {
            if (!proxy.isActive()) {
                continue;
            }

            proxy = proxy.clone();

            request.addProxy(proxy);
        }

        // <mirrors>
        //   <mirror>

    }

    @Override
    public boolean isLoading() {
      return true;
    }

    @Override
    public boolean isActive() {
      return oldValue.isActive();
    }

    @Override
    public int getWeight() {
      return oldValue.getWeight();
    }

    @CanIgnoreReturnValue

  void assertThreadStaysAlive(Thread thread, long millis) throws InterruptedException {
    // No need to optimize the failing case via Thread.join.
    delay(millis);
    assertTrue(thread.isAlive());
  }

  /**
   * Checks that the threads do not terminate within the default millisecond delay of {@code
   * timeoutMillis()}.
   */