)

type RootArgs struct {
	// DryRun performs all steps except actually applying the manifests or creating output dirs/files.
	DryRun bool
}

func addFlags(cmd *cobra.Command, rootArgs *RootArgs) {
	cmd.PersistentFlags().BoolVarP(&rootArgs.DryRun, "dry-run", "",
		false, "Console/log output only, make no changes.")
}

// GetRootCmd returns the root of the cobra command-tree.

        final TimeoutTask task = new TimeoutTask(timeoutTarget, timeout, permanent);
        timeoutTaskList.addLast(task);
        start();
        return task;
    }

    /**
     * 管理している {@link TimeoutTask}の数を返します。
     *
     * @return 管理している {@link TimeoutTask}の数
     */

          taskRunner.condition.signalAll()
        }
      }

    if (strategy == ResumePriority.BeforeOtherTasks) {
      serialTaskQueue.addFirst(yieldCompleteTask)
    } else {
      serialTaskQueue.addLast(yieldCompleteTask)
    }

    val startedTask = startNextTask()
    val otherTasksStarted = startedTask != yieldCompleteTask

    try {
      while (currentTask != self) {

		"log_rotate_max_size", "log_stacktrace_level", "log_target", "log_caller", "log_output_level",
	}
	for _, opt := range hiddenFlags {
		_ = rootCmd.PersistentFlags().MarkHidden(opt)
	}

	cmd.AddFlags(rootCmd)

	kubeInjectCmd := kubeinject.InjectCommand(ctx)
	hideInheritedFlags(kubeInjectCmd, cli.FlagNamespace)
	rootCmd.AddCommand(kubeInjectCmd)

	experimentalCmd := &cobra.Command{

			p := NewPrinterForWriter(cmd.OutOrStderr())
			p.Printf("%v\n", art.IstioColoredArt())
			return Install(kubeClient, rootArgs, iArgs, cmd.OutOrStdout(), l, p)
		},
	}

	addFlags(ic, rootArgs)
	addInstallFlags(ic, iArgs)
	return ic
}

// InstallCmd generates an Istio install manifest and applies it to a cluster
func InstallCmd(ctx cli.Context) *cobra.Command {

                if (phase != null) {
                    Deque<String> phases = getLifecycles(project);
                    if (!Objects.equals(phase, phases.peekLast())) {
                        phases.addLast(phase);
                        if ("clean".equals(phase)) {
                            cleanProjectLocalRepository(project);
                        }
                    }
                }
                break;

                return false
            }

            return true
        }

        private inline fun withElement(element: FirElement, block: () -> Unit) {
            stack.addLast(element)
            try {
                block()
            } finally {
                stack.removeLast()
            }
        }
    }

    @Override
    public void addFirst(E e) {
      synchronized (mutex) {
        delegate().addFirst(e);
      }
    }

    @Override
    public void addLast(E e) {
      synchronized (mutex) {
        delegate().addLast(e);
      }
    }

    @Override
    public boolean offerFirst(E e) {
      synchronized (mutex) {
        return delegate().offerFirst(e);
      }
    }