limitations under the License.
*/

package workflow

import (
	"fmt"

	"github.com/pkg/errors"
	"github.com/spf13/cobra"
)

var myWorkflowRunner = NewRunner()

type myWorkflowData struct {
	data string
}

func (c *myWorkflowData) Data() string {
	return c.data
}

type myPhaseData interface {
	Data() string
}

func ExamplePhase() {

type Runner struct {
	lock      sync.Mutex
	loopFuncs []func(stop chan struct{})
	stop      *chan struct{}
}

// NewRunner makes a runner for the given function(s). The function(s) should loop until
// the channel is closed.
func NewRunner(f ...func(stop chan struct{})) *Runner {
	return &Runner{loopFuncs: f}
}

// Start begins running.
func (r *Runner) Start() {
	r.lock.Lock()

		t.Run(test.Name, func(t *testing.T) {
			pkiutiltesting.Reset()

			tmpdir := testutil.SetupTempDir(t)
			defer os.RemoveAll(tmpdir)

			certstestutil.WritePKIFiles(t, tmpdir, test.Files)

			r := workflow.NewRunner()
			r.AppendPhase(NewCertsPhase())
			r.SetDataInitializer(func(*cobra.Command, []string) (workflow.RunData, error) {
				certsData := &testCertsData{
					cfg: testutil.GetDefaultInternalConfig(t),
				}

			lock.Unlock()
			<-c
			lock.Lock()
			events = append(events, fmt.Sprintf("%v stopping\n", iCopy))
			lock.Unlock()
			done <- struct{}{}
		})
	}

	r := NewRunner(funcs...)
	r.Start()
	r.Stop()
	for i := 0; i < 10; i++ {
		<-done
	}
	if len(events) != 20 {
		t.Errorf("expected 20 events, but got:\n%v\n", events)
	}

	// It corresponds to the relative path of the phase in the workflow managed by the Runner.
	use string
}

// NewRunner return a new runner for composable kubeadm workflows.
func NewRunner() *Runner {
	return &Runner{
		Phases: []Phase{},
	}
}

// AppendPhase adds the given phase to the ordered sequence of phases managed by the runner.

	runningTasks   sets.String
	runningTasksMu sync.RWMutex

	// runningTasksTicker is the report interval for running tasks.
	runningTasksTicker *time.Ticker
}

func NewRunner(activeRqLimit int) *Runner {
	if activeRqLimit <= 0 {
		activeRqLimit = defaultActiveRequestLimit
	}
	return &Runner{
		taskSem:            make(chan struct{}, activeRqLimit),
		runningTasks:       sets.New[string](),

	outputWriter          io.Writer
}

// newCmdNode returns the cobra command for `kubeadm upgrade node`
func newCmdNode(out io.Writer) *cobra.Command {
	nodeOptions := newNodeOptions()
	nodeRunner := workflow.NewRunner()

	cmd := &cobra.Command{
		Use:   "node",
		Short: "Upgrade commands for a node in the cluster",
		RunE: func(cmd *cobra.Command, args []string) error {

func newCmdReset(in io.Reader, out io.Writer, resetOptions *resetOptions) *cobra.Command {
	if resetOptions == nil {
		resetOptions = newResetOptions()
	}
	resetRunner := workflow.NewRunner()

	cmd := &cobra.Command{
		Use:   "reset",
		Short: "Performs a best effort revert of changes made to this host by 'kubeadm init' or 'kubeadm join'",
		RunE: func(cmd *cobra.Command, args []string) error {

		// than 1 minute for backward compatibility of failing the whole
		// apiserver if we can't repair them.
		wg := sync.WaitGroup{}
		wg.Add(2)
		runner := async.NewRunner(
			func(stopCh chan struct{}) { p.startServiceClusterIPRepair(wg.Done, stopCh) },
			func(stopCh chan struct{}) { p.startServiceNodePortsRepair(wg.Done, stopCh) },
		)
		runner.Start()
		go func() {

	// Aggregated errors for all fetch operations.
	gErrors util.Errors
	lock    = sync.RWMutex{}
)

func runBugReportCommand(ctx cli.Context, _ *cobra.Command, logOpts *log.Options) error {
	runner := kubectlcmd.NewRunner(gConfig.RequestConcurrency)
	runner.ReportRunningTasks()
	if err := configLogs(logOpts); err != nil {
		return err
	}
	config, err := parseConfig()
	if err != nil {
		return err
	}