// Generate and print the upgrade plan
	plan := genUpgradePlan(availUpgrades, configVersionStates)
	return printer.PrintObj(plan, os.Stdout)
}

// genUpgradePlan generates upgrade plan from available upgrades and component config version states
func genUpgradePlan(availUpgrades []upgrade.Upgrade, configVersions []outputapiv1alpha3.ComponentConfigVersionState) *outputapiv1alpha3.UpgradePlan {

)

// Plan for configuration that can be applied or deleted as an atomic unit.
// A Plan is initially created by a Factory, but then can continually be
// appended to before finally calling Apply or Delete.
type Plan interface {
	// Factory for appending to this Config.
	Factory

	// Copy returns a deep copy of this Plan.
	Copy() Plan

	// Apply this config.

    }

    taskFaker.runTasks()
    assertEvents(
      "take plan 0",
      "plan 0 TCP connecting...",
      "plan 0 TCP connected",
      "plan 0 TLS connecting...",
      "plan 0 needs follow-up",
      "plan 1 TCP connecting...",
      "plan 1 TCP connected",
      "plan 1 TLS connecting...",
      "plan 1 TLS connected",
    )

    taskFaker.assertNoMoreTasks()
  }

  /**

    if (plan is FailedPlan) return plan.result

    // Connect TCP asynchronously.
    tcpConnectsInFlight += plan
    val taskName = "$okHttpName connect ${routePlanner.address.url.redact()}"
    taskRunner.newQueue().schedule(
      object : Task(taskName) {
        override fun runOnce(): Long {
          val connectResult =
            try {
              plan.connectTcp()

// limitations under the License.

package config

// Factory for config Plan resources.
type Factory interface {
	// New return an empty config Plan.
	New() Plan

	// YAML returns a Plan with the given YAML and target namespace.
	YAML(ns string, yamlText ...string) Plan

	// File reads the given files and calls YAML.
	File(ns string, paths ...string) Plan

	// Eval the same as YAML, but it evaluates the template parameters.

    }

    @Override
    public void populateWorkGraph(GradleInternal gradle, ExecutionPlan plan, Consumer<? super ExecutionPlan> action) {
        action.accept(plan);
        plan.determineExecutionPlan();
    }

    @Override
    public FinalizedExecutionPlan finalizeWorkGraph(GradleInternal gradle, ExecutionPlan plan) {
        TaskExecutionGraphInternal taskGraph = gradle.getTaskGraph();

import org.gradle.api.NonNullApi;
import org.gradle.api.Task;
import org.gradle.api.internal.GradleInternal;
import org.gradle.execution.plan.ExecutionPlan;
import org.gradle.execution.plan.FinalizedExecutionPlan;
import org.gradle.execution.plan.QueryableExecutionPlan;
import org.gradle.execution.plan.ToPlannedNodeConverterRegistry;
import org.gradle.internal.operations.BuildOperationContext;

    fun handleSuccess(): RealConnection

    fun cancel()

    /**
     * Returns a plan to attempt if canceling this plan was a mistake! The returned plan is not
     * canceled, even if this plan is canceled.
     */
    fun retry(): Plan?
  }

  /**
   * What to do once a plan has executed.
   *
   * If [nextPlan] is not-null, another attempt should be made by following it. If [throwable] is

        when:
        action.scheduleRequestedTasks(gradle, selector, plan)

        then:
        1 * delegate.scheduleRequestedTasks(gradle, selector, plan)
    }

    def "proceeds when no task requests specified in StartParameter"() {
        given:
        _ * startParameter.taskRequests >> []

        when:
        action.scheduleRequestedTasks(gradle, selector, plan)

        then:

import org.gradle.api.internal.GradleInternal;
import org.gradle.execution.plan.ExecutionPlan;
import org.gradle.execution.plan.FinalizedExecutionPlan;

import java.util.function.Consumer;

public interface BuildWorkPreparer {
    /**
     * Creates a new, empty plan.
     */
    ExecutionPlan newExecutionPlan();

    /**
     * Populates the given execution plan using the given action.
     */