## Version 4.2.1

_2019-10-02_

 *  Fix: In 4.1.0 we introduced a performance regression that prevented connections from being
    pooled in certain situations. We have good test coverage for connection pooling but we missed
    this because it only occurs if you have proxy configured and you share a connection pool among
    multiple `OkHttpClient` instances.

                    Map<String, LifecyclePhase> phases = getLifecyclePhases(lifecycleId);
                    if (phases != null) {
                        Lifecycle lifecycle = new Lifecycle();

                        lifecycle.setId(lifecycleId);
                        lifecycle.setLifecyclePhases(phases);

                        lifecycleMap.put(lifecycleId, lifecycle);
                    }

                new SiteLifecycle(),
                new WrapperLifecycle());
        // validate lifecycle
        for (Lifecycle lifecycle : this) {
            Set<String> set = new HashSet<>();
            lifecycle.phases().forEach(phase -> {
                if (!set.add(phase.name())) {
                    throw new IllegalArgumentException(

        this.id = lifecycle.id();
        this.phases = registry.computePhases(lifecycle);
        this.defaultPhases = getDefaultPhases(lifecycle);
    }

    // <lifecycle>
    //   <id>clean</id>
    //   <phases>
    //     <phase>pre-clean</phase>
    //     <phase>clean</phase>
    //     <phase>post-clean</phase>
    //   </phases>
    //   <default-phases>

     *
     * @return the unique identifier for this lifecycle
     */
    @Override
    String id();

    /**
     * Collection of phases for this lifecycle
     */
    Collection<Phase> phases();

    /**
     * Pre-ordered list of phases.
     * If not provided, a default order will be computed.
     */
    default Optional<List<String>> orderedPhases() {
        return Optional.empty();
    }

                    MojoNotFoundException, InvalidPluginDescriptorException {
        /*
         * Initialize mapping from lifecycle phase to bound mojos. The key set of this map denotes the phases the caller
         * is interested in, i.e. all phases up to and including the specified phase.
         */

        Map<String, Map<Integer, List<MojoExecution>>> mappings = new LinkedHashMap<>();

void TFE_InferShapes(TFE_Op* tfe_op, TF_ShapeAndTypeList* input_shapes,
                     TF_Tensor** input_tensors,
                     TF_ShapeAndTypeList* input_tensors_as_shapes,
                     TF_ShapeAndTypeList** input_resource_shapes_and_types,
                     TF_ShapeAndTypeList** output_shapes,
                     TF_ShapeAndTypeList*** output_resource_shapes_and_types,
                     TF_Status* status) {

            want to analyze the set of transitive dependencies, in particular during early lifecycle phases where
            full dependency resolution might fail due to projects which haven't been built yet.
          </description>
        </field>
        <field>
          <name>dependencyCollection</name>
          <version>2.0.0+</version>

        private final String name;
        private final List<Plugin> plugins;
        private final List<Lifecycle.Phase> phases;

        DefaultPhase(String name, List<Plugin> plugins, List<Lifecycle.Phase> phases) {
            this.name = name;
            this.plugins = plugins;
            this.phases = phases;
        }

        @Override
        public String name() {
            return name;
        }

| [AWS-KMS + SecretsManager](https://github.com/minio/kes/wiki/AWS-SecretsManager)             | Cloud KMS. MinIO in combination with a managed KMS installation   |
| [Gemalto KeySecure /Thales CipherTrust](https://github.com/minio/kes/wiki/Gemalto-KeySecure) | Local KMS. MinIO and KMS On-Premises.                             |