// 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.

    assertEvents(
      "take plan 1",
      "plan 1 TCP connecting...",
    )

    taskFaker.advanceUntil(260.ms)
    assertEvents(
      "plan 1 TCP connected",
      "plan 0 cancel",
      "plan 1 TLS connecting...",
      "plan 1 TLS connect failed",
      "plan 2 TCP connecting...",
      "plan 2 TCP connected",
      "plan 2 TLS connecting...",
      "plan 2 TLS connected",
    )

    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()

 */
interface RoutePlanner {
  val address: Address

  /** Follow-ups for failed plans and plans that lost a race. */
  val deferredPlans: ArrayDeque<Plan>

  fun isCanceled(): Boolean

  /** Returns a plan to attempt. */
  @Throws(IOException::class)
  fun plan(): Plan

  /**
   * Returns true if there's more route plans to try.
   *

        def controller = controller()

        controller.prepareToScheduleTasks()
        def plan = controller.newWorkGraph()
        controller.populateWorkGraph(plan) { b -> b.addRequestedTasks() }
        controller.finalizeWorkGraph(plan)
        def executionResult = controller.executeTasks(plan)
        executionResult.failures.empty

        def finishResult = controller.finishBuild(null)

// 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;

        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: